mirror of
https://gitlab.com/pamhyr/pamhyr2.git
synced 2026-10-30 03:20:41 +01:00
347 lines
16 KiB
Python
347 lines
16 KiB
Python
"""Rubar parameter descriptions (notice sections 3.1, 3.10 and annex 1).
|
||
|
||
Keys and values keep their historical database representation.
|
||
"""
|
||
|
||
from dataclasses import dataclass
|
||
from decimal import Decimal, DecimalException, InvalidOperation
|
||
|
||
from Solver.RubarBE import Rubar3
|
||
|
||
|
||
GROUPS = ('Temps et calcul', 'Hydraulique', 'Transport solide',
|
||
'Évolution du fond', 'Sauvegardes')
|
||
YES_NO = {'y': 'Oui', 'n': 'Non'}
|
||
ON_OFF = {'1': 'Oui', '0': 'Non'}
|
||
LAWS = {
|
||
'1': 'Meyer-Peter et Müller', '2': 'Engelund et Hansen', '3': 'Bagnold',
|
||
'8': 'Ackers et White (1973)', '9': 'Smart et Jaeggi', '10': 'van Rijn',
|
||
'11': 'Rickenmann', '12': 'Camenen et Larson', '13': 'Schoklitsch',
|
||
'14': 'Sato, Hikkawa et Ashida', '15': 'Recking et al. (2008)',
|
||
'16': 'Brownlie', '17': 'Laursen', '18': 'Ackers et White (1990)',
|
||
'19': 'Karim', '20': 'Karim et Kennedy', '21': 'Yang et Lim (2003)',
|
||
'22': 'Yang (1984)', '23': 'Yang (1979)', '24': 'Yang (1973)',
|
||
'25': 'van Rijn (1984) — suspension', '26': 'van Rijn (1984) — charriage',
|
||
'27': 'Recking et al. (2016)', '28': 'Piton et al. (2017)',
|
||
'29': 'Lefort (2007)', '30': 'Lefort (2015)',
|
||
}
|
||
OPTION_CHOICES = (
|
||
('Correction de pente',
|
||
{'1': 'Correction d’Ikeda', '2': 'Sans correction'},
|
||
'Permet d\'introduire que la répartition de la contrainte critique dans '
|
||
'une section en travers est influencée par la pente transversale'),
|
||
('Seuil critique', {'1': 'Fourni par l’utilisateur',
|
||
'2': 'Calculé par le diagramme de Shields'},
|
||
'Permet de choisir pour certaines formules de capacité, entre un seuil '
|
||
'critique fourni par l’utilisateur ou '
|
||
'un seuil critique calculé par le diagramme de Shields.'),
|
||
('Contrainte utilisée', {'1': 'Contrainte efficace',
|
||
'2': 'Contrainte non réduite'},
|
||
'Permet de choisir pour certaines formules de capacité, entre la '
|
||
'contrainte efficace calculée ou la contrainte non réduite.'),
|
||
)
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class Field:
|
||
key: str
|
||
group: int
|
||
label: str
|
||
help: str
|
||
kind: str = 'real'
|
||
choices: dict = None
|
||
minimum: float = 0
|
||
maximum: float = None
|
||
positive: bool = False
|
||
optional: bool = False
|
||
|
||
|
||
def fields():
|
||
"""Describe historical Rubar fields without changing their defaults."""
|
||
result = []
|
||
|
||
def add(key, group, label, help, **kwargs):
|
||
result.append(Field('rubarbe_' + key, group, label, help, **kwargs))
|
||
|
||
def choice(key, group, label, help, choices):
|
||
add(key, group, label, help, kind='choice', choices=choices)
|
||
|
||
add('cfl', 0, 'Nombre de Courant (CFL)',
|
||
'Limite supérieure du nombre de Courant, afin d\'assurer la stabilité '
|
||
'du schéma numérique ; comprise entre 0 et 1.',
|
||
positive=True, maximum=1)
|
||
for key, label, help in (
|
||
('tinit', 'Début du calcul',
|
||
'Doit correspondre aux conditions initiales.'),
|
||
('tmax', 'Fin du calcul', 'Doit être postérieure au début du calcul.'),
|
||
):
|
||
add(key, 0, label + ' (j:h:min:s ou s)', help, kind='time')
|
||
choice('iopdt', 0, 'Gestion du pas de temps',
|
||
'En mode mixte, le pas reste fixe jusqu’à la date de bascule.',
|
||
{'y': 'Automatique', 'n': 'Fixe',
|
||
'm': 'Mixte : fixe puis automatique'})
|
||
add('dt', 0, 'Pas de temps initial ou fixe (s)',
|
||
'Premier pas en mode automatique, pas demandé en mode fixe.',
|
||
positive=True)
|
||
add('tiopdt', 0, 'Fin de la période à pas fixe' + ' (j:h:min:s ou s)',
|
||
'Utilisée uniquement avec un pas de temps mixte.', kind='time')
|
||
choice('rep', 0, 'Reprendre un calcul',
|
||
'Nécessite les fichiers de reprise du calcul précédent.', YES_NO)
|
||
|
||
choice('condam', 1, 'Condition à la limite amont',
|
||
'Le choix doit correspondre aux données de la limite amont.',
|
||
{'0': 'Réflexion', '1': 'Débit imposé Q(t)',
|
||
'2': 'Cote imposée Z(t)', '4': 'Confluence'})
|
||
choice('condav', 1, 'Condition à la limite aval',
|
||
'Le choix doit correspondre aux données de la limite aval.',
|
||
{'0': 'Sortie libre', '1': 'Courbe de tarage Q(Z)',
|
||
'2': 'Réflexion',
|
||
'3': 'Cote imposée Z(t)', '4': 'Confluence / défluence',
|
||
'5': 'Régime uniforme', '7': 'Régime critique'})
|
||
choice('regime', 1, 'Imposer aussi le tirant d’eau amont',
|
||
'Complète le débit imposé ; incompatible avec une limite '
|
||
'amont de type "Réflexion".',
|
||
ON_OFF)
|
||
choice('iodev', 1, 'Déversement latéral',
|
||
'Nécessite les données de déversements latéraux.',
|
||
YES_NO)
|
||
for key, label, help in (
|
||
('iodebord', 'Formule Debord',
|
||
'Oui: utilise la formule Debord pour les lits composés.\nNon:'
|
||
' pas de perte de charge complémentaire entre lit mineur et moyen.'),
|
||
('iostockage', 'Stockage dans le lit majeur',
|
||
'Traite le lit majeur sous la berge la plus basse comme zone '
|
||
'de stockage.'),
|
||
):
|
||
choice(key, 1, label, help, YES_NO)
|
||
choice('optfpc', 1, 'Calcul du frottement',
|
||
'Strickler fourni ou frottement calculé à partir des sédiments.',
|
||
{'0': 'Coefficients de Strickler fournis', '1': 'Brownlie (1983)',
|
||
'2': 'Griffith (1981) - pour un fond mobile', '3': 'Karim (1995)',
|
||
'4': 'Wu et Wang (1999)', '5': 'Yu et Lim (2003)',
|
||
'6': 'Recking et al. (2008)', '7': 'Garde et Raju (1966)'})
|
||
for key, label in (
|
||
('ros', 'Masse volumique des sédiments (kg/m³)'),
|
||
('dm', 'Diamètre médian des sédiments (m)'),
|
||
('segma', 'Étendue granulométrique des sédiments (—)'),
|
||
):
|
||
add(key, 1, label,
|
||
'Utilisé pour le frottement calculé sans transport solide '
|
||
'(disponible uniquement si le transport solide est désactivé '
|
||
'et que le calcul du frottement se fait avec les sédiments).',
|
||
positive=True)
|
||
|
||
choice('trased', 2, 'Activer le transport solide',
|
||
'Fonction de RubarBE. L’évolution du fond se règle séparément.',
|
||
YES_NO)
|
||
add('sediment_ros', 2, 'Masse volumique des sédiments (kg/m³)',
|
||
'Masse volumique des grains.', positive=True)
|
||
add('sediment_por', 2, 'Porosité des sédiments (—)',
|
||
'Fraction du volume occupée par les vides : de 0 inclus à 1 exclu.',
|
||
positive=True, maximum=1)
|
||
choice('sediment_opts', 2, 'Loi de capacité solide',
|
||
'Formule de capacité solide ; choisir selon le domaine '
|
||
'physique.',
|
||
LAWS)
|
||
choice('sediment_unisol', 2, 'Unité des débits ou concentrations solides',
|
||
'Unité des débits ou concentrations solides.',
|
||
{'1': 'Débit massique (kg/s)', '2': 'Concentration (kg/m³)'})
|
||
choice('sediment_odchar', 2, 'Distance de chargement',
|
||
'Option de calcul de la ditance de chargement.',
|
||
{'0': 'Distance constante', '1': 'Loi de Han', '2': 'Wu et Wang'})
|
||
add('sediment_dcharg', 2, 'Distance de chargement constante (m)',
|
||
'Utilisée uniquement si la distance de chargement est constante.')
|
||
add('sediment_halfa', 2, 'Paramètre alpha de Han (m)',
|
||
'Utilisé uniquement avec la loi de chargement de Han.')
|
||
add('sediment_option', 2, 'Calcul de la contrainte critique',
|
||
'Trois choix indépendants, enregistrés ensemble dans OPTION.',
|
||
kind='options')
|
||
add('sediment_visc', 2, 'Viscosité ou seuil critique',
|
||
'Selon la configuration : seuil critique adimensionnel fourni, ou '
|
||
'viscosité cinématique de l’eau. À 15 °C : environ 1,30 × 10⁻⁶ m²/s. '
|
||
'Un changement de mode ne convertit pas la valeur.', positive=True)
|
||
choice('sediment_choixc', 2, 'Calcul de la contrainte hydrodynamique de '
|
||
'cisaillement',
|
||
'MPC : méthode des perpendiculaires confondues (notice §8.5).',
|
||
{'1': 'MPC', '2': 'Répartition uniforme',
|
||
'3': 'MPC — pente moyenne sur 3 segments',
|
||
'4': 'MPC — moyenne sur 3 segments',
|
||
'5': 'MPC — moyenne sur une distance de périmètre de '
|
||
'longueur égale à la hauteur d’eau',
|
||
'6': 'MPC — proportionnelle au diamètre de la couche '
|
||
'puissance 1/3',
|
||
'7': 'MPC — proportionnelle au Strickler puissance −3/2',
|
||
'8': 'MPC — proportionnelle à la hauteur d’eau'})
|
||
choice('sediment_capsol', 2, 'Calcul de la capacité solide',
|
||
'Les méthodes 2 et 3 nécessitent une répartition MPC.',
|
||
{'1': 'Contrainte moyenne, largeur active imposée',
|
||
'2': 'Contrainte moyenne, largeur active calculée',
|
||
'3': 'Répartition locale des contraintes'})
|
||
add('sediment_mult_1', 2, 'Multiplicateur de la capacité de chariage (—)',
|
||
'1 conserve la capacité calculée par la loi choisie.')
|
||
|
||
choice('sediment_defond', 3, 'Faire évoluer la géométrie du lit',
|
||
'Le transport solide peut être calculé sans déformation du lit.',
|
||
ON_OFF)
|
||
choice('sediment_demix', 3, 'Activer le démixage',
|
||
'Option pour le demixage de deux compartiments sédimentaires.',
|
||
ON_OFF)
|
||
for key, label in (
|
||
('dchard', 'Distance de chargement pour le diamètre de sédiment (m)'),
|
||
('dchars', 'Distance de chargement de l’étendue granulométrique des '
|
||
'sédiments (m)'),
|
||
):
|
||
add('sediment_' + key, 3, label,
|
||
'Utilisée uniquement lorsque le démixage est activé.')
|
||
choice('sediment_typdef', 3, 'Actualisation de la masse active',
|
||
'Actualise la masse active après une variation relative de 10⁻ⁿ.',
|
||
{'0': 'À chaque pas', '1': 'Variation de 10 %',
|
||
'2': 'Variation de 1 %', '3': 'Variation de 0,1 %',
|
||
'4': 'Variation de 0,01 %'})
|
||
choice('sediment_depot', 3, 'Méthode d\'application du dépôt',
|
||
'Méthodes de déformation de la section décrites au §8.5.3.',
|
||
{'1': 'Couches horizontales',
|
||
'2': 'Uniforme sur le périmètre mouillé',
|
||
'3': 'Inverse de la contrainte locale (1/τ)',
|
||
'4': 'Selon le seuil critique — tout le lit actif mouillé',
|
||
'5': 'Selon le seuil critique — une partie du lit actif mouillé',
|
||
'6': 'Méthode 6 — fonction des contraintes (notice §8.5.3)',
|
||
'7': 'Méthode 7 — fonction des contraintes (notice §8.5.3)',
|
||
'8': 'Méthode 8 — code cité dans l’annexe 1'})
|
||
choice('sediment_varcons', 3, 'Grandeurs conservées après déformation',
|
||
'Les autres grandeurs hydrauliques sont recalculées.',
|
||
{'1': 'Section mouillée et débit', '2': 'Niveau d’eau et débit',
|
||
'3': 'Niveau d’eau et vitesse'})
|
||
add('sediment_bmiu', 3, 'Tangente de l’angle de frottement interne (—)',
|
||
'Saisir tan(angle), et non l’angle en degrés, de la valeur moyenne '
|
||
'de la tangente de l\'angle de frottement interne de sédiments.',
|
||
positive=True)
|
||
for i, label in enumerate((
|
||
'Épaisseur de couche active : multiplicateur du d84',
|
||
'Épaisseur de fines infiltrantes : multiplicateur du d16',
|
||
'Coefficient de mélange des couches superficielles',
|
||
'Coefficient de création d’une couche de dépôt',
|
||
), 2):
|
||
add(f'sediment_mult_{i}', 3, label + ' (—)',
|
||
'Facultatif : laisser vide pour utiliser le comportement '
|
||
'du solveur.',
|
||
optional=True)
|
||
|
||
for key, label, help in (
|
||
('ts', 'Instant de sauvegarde pour reprise',
|
||
'Écrit les fichiers de reprise lorsque cet instant est dépassé.'),
|
||
('dtsauv', 'Intervalle de sauvegarde des profils',
|
||
'0 demande une sauvegarde à chaque pas de calcul.'),
|
||
('psave', 'Intervalle de sauvegarde des hydrogrammes',
|
||
'0 demande une sauvegarde à chaque pas de calcul.'),
|
||
):
|
||
add(key, 4, label + ' (j:h:min:s ou s)', help, kind='time')
|
||
for i, label in enumerate((
|
||
'Fichiers de reprise', 'Hydrogrammes aux abscisses choisies',
|
||
'Enveloppes des résultats', 'Profils aux instants choisis',
|
||
'Profils à intervalle fixe', 'Temps de dépassement des débits',
|
||
), 1):
|
||
choice(f'tf_{i}', 4, label,
|
||
'Les abscisses ou instants demandés '
|
||
'doivent être définis dans les données correspondantes.',
|
||
YES_NO)
|
||
for i in range(1, 4):
|
||
add(f'fdeb{i}', 4, f'Seuil de débit du front {i} (m³/s)',
|
||
'Débit pour lequel à chaque abscisse, est enregistré le temps '
|
||
'de premier dépassement (fichier TRAJEC si demandé).',
|
||
positive=True)
|
||
choice('iovis', 4, 'Sorties complémentaires',
|
||
'Largeurs et sorties complémentaires hydrauliques et '
|
||
'sédimentaires.',
|
||
YES_NO)
|
||
return {field.key: field for field in result}
|
||
|
||
|
||
FIELDS = fields()
|
||
|
||
|
||
def canonical(field, value):
|
||
value = str(value).strip()
|
||
if field.choices and 'y' in field.choices:
|
||
aliases = {'o': 'y', 'y': 'y', 'n': 'n', 'm': 'm'}
|
||
return aliases.get(value.lower(), value)
|
||
return value
|
||
|
||
|
||
def validate(field, value):
|
||
"""Return a storage value or raise a user-facing validation error."""
|
||
value = canonical(field, value)
|
||
if field.kind == 'choice':
|
||
if value not in field.choices:
|
||
raise ValueError('Choisissez une valeur dans la liste.')
|
||
return value
|
||
if field.kind == 'options':
|
||
if len(value) != 3 or any(c not in '12' for c in value):
|
||
raise ValueError('Renseignez les trois choix de contrainte.')
|
||
return value
|
||
if field.kind == 'text':
|
||
return value
|
||
if not value and field.optional:
|
||
return value
|
||
value = value.replace(',', '.').replace('d', 'E').replace('D', 'E')
|
||
try:
|
||
if field.kind == 'time' and ':' in value:
|
||
parts = value.split(':')
|
||
valid = all(p.isascii() and p.isdigit() for p in parts)
|
||
if len(parts) != 4 or not valid:
|
||
raise ValueError(
|
||
'Utilisez j:h:min:s ou un nombre de secondes.')
|
||
number = sum(Decimal(p) * factor for p, factor in
|
||
zip(parts, (86400, 3600, 60, 1)))
|
||
else:
|
||
number = Decimal(value)
|
||
except InvalidOperation:
|
||
raise ValueError('Saisissez un nombre fini.') from None
|
||
if not number.is_finite():
|
||
raise ValueError('Saisissez un nombre fini.')
|
||
if number < field.minimum or (field.positive and number == 0):
|
||
raise ValueError('La valeur doit être strictement positive.'
|
||
if field.positive else
|
||
'La valeur doit être positive ou nulle.')
|
||
if field.maximum is not None and number > field.maximum:
|
||
raise ValueError(f'La valeur ne doit pas dépasser {field.maximum}.')
|
||
if field.key == 'rubarbe_sediment_por' and number >= 1:
|
||
raise ValueError('La porosité doit être inférieure à 1.')
|
||
scientific = not field.key.startswith('rubarbe_sediment_')
|
||
try:
|
||
Rubar3._real(str(number), field.key, scientific=scientific)
|
||
except (ValueError, DecimalException, OverflowError):
|
||
raise ValueError(
|
||
'Valeur trop longue ou hors plage pour le format du solveur '
|
||
'(12 colonnes).' if scientific else
|
||
'Valeur trop précise ou hors plage pour le format du solveur '
|
||
'(10 colonnes).') from None
|
||
return value
|
||
|
||
|
||
def active(field, values):
|
||
"""Dependencies only disable editing; stored values are never erased."""
|
||
key = field.key.removeprefix('rubarbe_')
|
||
transport = values.get('rubarbe_trased', 'n').lower() in ('y', 'o')
|
||
if key.startswith('sediment_') and not transport:
|
||
return False
|
||
if key == 'tiopdt':
|
||
return values.get('rubarbe_iopdt', '').lower() == 'm'
|
||
if key in ('ros', 'dm', 'segma'):
|
||
return (not transport and
|
||
values.get('rubarbe_optfpc', '0') not in ('', '0'))
|
||
dependencies = {
|
||
'sediment_dcharg': ('sediment_odchar', ('0',)),
|
||
'sediment_halfa': ('sediment_odchar', ('1',)),
|
||
'sediment_dchard': ('sediment_demix', ('1',)),
|
||
'sediment_dchars': ('sediment_demix', ('1',)),
|
||
'sediment_varcons': ('sediment_defond', ('1',)),
|
||
'sediment_depot': ('sediment_defond', ('1',)),
|
||
}
|
||
if key in dependencies:
|
||
source, accepted = dependencies[key]
|
||
return values.get('rubarbe_' + source) in accepted
|
||
if key.startswith('fdeb'):
|
||
return values.get('rubarbe_tf_6', 'n').lower() in ('y', 'o')
|
||
return True
|