Les bilans massiques d'usines pilotes multi-composants peuvent être résolus en Python en exprimant les équations indépendantes sous forme de système matriciel (A\mathbf{x}=\mathbf{b}) et en résolvant pour les débits de courant, les concentrations ou les taux de réaction inconnus. Pour un modèle linéaire entièrement spécifié, la fonction numpy.linalg.solve() de NumPy fournit la solution ; les systèmes sous-déterminés, surdéterminés ou non linéaires nécessitent des méthodes différentes.

La clé n'est pas la commande Python elle-même, mais la construction préalable d'un ensemble d'équations physiquement correct et indépendant. Définissez des limites de système claires, effectuez une vérification des degrés de liberté, assemblez (A) et (\mathbf{b}) avec des unités cohérentes, puis sélectionnez un solveur approprié au modèle.

Convertir l'usine pilote en équations

Définir les limites du système

Pour une usine pilote entière, la limite globale inclut les alimentations externes et les produits finaux, mais exclut les courants internes entre les unités.

Pour un réacteur, un séparateur, un mélangeur ou une jonction de recyclage, définissez une limite de sous-système distincte et incluez uniquement les courants traversant cette limite. Cela évite que les courants internes ne soient comptés de manière incorrecte dans un bilan global.

Écrire les bilans de composants

Pour chaque composant non réactif en régime permanent :

[ \sum \dot{n}{i,\text{in}}-\sum \dot{n}{i,\text{out}}=0 ]

où (\dot{n}_i) est le débit molaire du composant (i).

Pour un composant réactif, incluez la génération ou la consommation :

[ \sum \dot{n}{i,\text{in}}-\sum \dot{n}{i,\text{out}} +\sum_j \nu_{ij}\xi_j=0 ]

Ici, (\nu_{ij}) est le coefficient stoechiométrique de l'espèce (i) dans la réaction (j), et (\xi_j) est l'avancement de la réaction.

Choisir les variables indépendantes

Le vecteur inconnu peut contenir :

Les débits des courants
Les débits des composants
Les concentrations ou compositions des courants
Les taux de recyclage
Les avancements de réaction
Les débits de fluides utilitaires inconnus, tels que les distributions de vapeur

Pour les systèmes réactifs, les avancements de réaction indépendants peuvent réduire le nombre d'inconnues. Si (M) réactions indépendantes sont identifiées, les quantités d'espèces peuvent être écrites comme :

[ N_i=N_{i,0}+\sum_{j=1}^{M}\nu_{ij}\xi_j ]

Cela évite d'introduire des variables de réaction redondantes.

Former le système matriciel en Python

Interpréter (A\mathbf{x}=\mathbf{b})

L'équation matricielle comporte trois parties :

(A) : coefficients des variables inconnues
(\mathbf{x}) : débits, concentrations ou avancements inconnus
(\mathbf{b}) : alimentations connues, spécifications et constantes

Par exemple, supposons que deux courants soient mélangés et que la sortie contienne 60 unités par heure du composant A. Soit :

[ \mathbf{x}= \begin{bmatrix} F_1\ F_2\ F_3 \end{bmatrix} ]

où (F_1) et (F_2) sont les débits d'alimentation et (F_3) est le débit de sortie total. Les équations sont :

[ F_1+F_2=100 ]

[ 0.8F_1+0.2F_2=60 ]

[ F_3-F_1-F_2=0 ]

Celles-ci deviennent :

[ \begin{bmatrix} 1 & 1 & 0\ 0.8 & 0.2 & 0\ -1 & -1 & 1 \end{bmatrix} \begin{bmatrix} F_1\ F_2\ F_3 \end{bmatrix}

\begin{bmatrix} 100\ 60\ 0 \end{bmatrix} ]

Implémenter le modèle avec NumPy

import numpy as np

A = np.array([
    [1.0, 1.0, 0.0],    # Bilan d'alimentation total
    [0.8, 0.2, 0.0],    # Bilan du composant A
    [-1.0, -1.0, 1.0]   # Spécification du débit de sortie
])

b = np.array([100.0, 60.0, 0.0])

# Vérifier la matrice des coefficients
rank_A = np.linalg.matrix_rank(A)

if rank_A < A.shape[1]:
    raise ValueError("Le système est sous-déterminé ou contient des variables dépendantes.")

x = np.linalg.solve(A, b)

F1, F2, F3 = x

print(f"F1 = {F1:.3f}")
print(f"F2 = {F2:.3f}")
print(f"F3 = {F3:.3f}")

La solution est approximativement :

F1 = 66.667
F2 = 33.333
F3 = 100.000

La fonction NumPy correcte est np.linalg.matrix_rank(). Une fonction nommée numpy.linalg.rank() n'est pas l'interface standard de NumPy.

Effectuer une vérification appropriée des degrés de liberté

Compter les inconnues et les équations indépendantes

Un système a zéro degré de liberté lorsque le nombre d'équations indépendantes correspond au nombre d'inconnues indépendantes.

Cependant, comparer simplement le nombre de lignes et de colonnes est insuffisant. Les équations peuvent être dupliquées, redondantes ou contradictoires.

Pour un système carré, vérifiez :

n_equations, n_unknowns = A.shape
rank_A = np.linalg.matrix_rank(A)

print("Équations :", n_equations)
print("Inconnues :", n_unknowns)
print("Rang :", rank_A)

Pour une solution unique, la matrice des coefficients doit être de plein rang colonne. Dans un système carré, cela signifie :

rank_A == A.shape[0] == A.shape[1]

Distinguer les systèmes sous-déterminés et surdéterminés

S'il y a moins d'équations indépendantes que d'inconnues, le système est sous-déterminé. Des spécifications ou des mesures supplémentaires sont requises.

S'il y a plus d'équations que d'inconnues, le système est surdéterminé. Cela se produit couramment lorsque les mesures de l'usine pilote contiennent de la redondance ou du bruit.

Utilisez np.linalg.lstsq() pour une estimation par moindres carrés :

x, residuals, rank_A, singular_values = np.linalg.lstsq(
    A, b, rcond=None
)

Cela estime les variables qui correspondent le mieux aux bilans mesurés plutôt que de forcer chaque mesure à concorder exactement.

Vérifier la cohérence, pas seulement le rang

Un système peut être de plein rang et contenir tout de même une erreur d'unité ou de données. Après la résolution, calculez le résidu :

residual = A @ x - b

print("Vecteur résiduel :", residual)
print("Résidu absolu maximum :", np.max(np.abs(residual)))

Pour un modèle exact, le résidu doit être proche de zéro dans les limites de la tolérance numérique.

Étendre la méthode aux réseaux d'usines pilotes

Modéliser plusieurs opérations unitaires

Un schéma de procédé contenant des mélangeurs, des réacteurs, des séparateurs et des boucles de recyclage peut être représenté en combinant les équations de chaque unité en une seule matrice globale.

Par exemple :

Écrivez les bilans de composants autour de chaque unité.
Ajoutez les équations reliant les courants de sortie aux courants d'entrée en aval.
Ajoutez les spécifications de récupération du séparateur ou de fraction de séparation.
Ajoutez les équations de stoechiométrie ou d'avancement de réaction.
Ajoutez les spécifications connues d'alimentation et de produit.
Assemblez toutes les équations dans (A\mathbf{x}=\mathbf{b}).

Les courants internes restent dans le vecteur global des inconnues, même s'ils s'annulent dans un bilan global de l'usine.

Inclure les courants de recyclage et de purge

Les systèmes de recyclage produisent souvent des équations simultanées car un courant en aval affecte une unité en amont via la boucle de recyclage.

Une relation de recyclage linéaire simple peut ressembler à :

[ R=\alpha(F+R) ]

qui peut être réorganisée en :

[ (1-\alpha)R=\alpha F ]

L'équation résultante peut être placée directement dans la matrice. Les fractions de recyclage spécifiques aux composants produisent des lignes supplémentaires pour chaque composant.

Une purge est modélisée de la même manière en ajoutant le débit de purge ou la fraction de purge comme une inconnue ou une spécification.

Inclure les réseaux de vapeur et d'utilités

Les collecteurs de vapeur à différentes pressions peuvent être modélisés en utilisant des équations de bilan de débit au niveau des collecteurs et des unités de traitement.

Pour chaque collecteur :

[ \text{vapeur entrée}+\text{vapeur générée}

\text{vapeur vers utilisateurs}+\text{vapeur détente}+\text{vapeur sortie} ]

Le vecteur inconnu peut contenir les débits à travers les collecteurs haute, moyenne et basse pression, les rebouilleurs de procédé, les retours de condensats et les vannes de détente.

La même approche matricielle s'applique, à condition que les relations énergétiques dépendantes de la pression soient soit spécifiées séparément, soit incorporées dans un modèle approprié.

Gérer les modèles d'usine pilote non linéaires

Reconnaître quand `np.linalg.solve()` n'est pas suffisant

Le solveur matriciel direct ne s'applique que lorsque les équations sont linéaires par rapport aux inconnues.

Un comportement non linéaire se produit avec :

Les relations d'équilibre
La cinétique de réaction non linéaire
Les propriétés dépendantes de la température
L'équilibre liquide-vapeur
Les corrélations de perte de charge
Les coefficients de transfert thermique dépendants du débit
Les termes de produit tels que (F x_i) lorsque les deux variables sont inconnues

Ces systèmes ne peuvent pas être représentés par une matrice constante (A) sans linéarisation.

Utiliser un solveur non linéaire

Pour les bilans algébriques non linéaires, utilisez SciPy :

import numpy as np
from scipy.optimize import root

def balances(x):
    F1, F2, T = x

    return np.array([
        F1 + F2 - 100.0,
        0.8 * F1 + 0.2 * F2 - 60.0,
        T - (300.0 + 0.1 * F1**2)
    ])

initial_guess = np.array([50.0, 50.0, 300.0])

solution = root(balances, initial_guess)

if not solution.success:
    raise RuntimeError(solution.message)

print(solution.x)
print("Résidus :", balances(solution.x))

L'estimation initiale, la mise à l'échelle des variables et les limites physiques peuvent fortement affecter les performances du solveur non linéaire.

Valider les résultats par rapport au processus physique

Vérifier la conservation

Après la résolution, recalculez indépendamment les bilans totaux et de composants.

Pour chaque composant :

[ \text{débit entrée} - \text{débit sortie} ]

doit être égal à zéro pour un composant non réactif, ou à la contribution nette attendue de la réaction pour un composant réactif.

Vérifier la faisabilité physique

Une solution mathématiquement valide peut rester physiquement impossible. Vérifiez que :

Les débits sont non négatifs.
Les fractions molaires se situent entre 0 et 1.
La somme des fractions molaires est égale à un.
Les avancements de réaction ne consomment pas plus de réactif que disponible.
Les fractions de récupération et de séparation se situent dans leurs plages autorisées.
Les valeurs de pression et de température sont dans les limites de l'équipement.

if np.any(x < 0):
    print("Attention : Débit négatif détecté.")

Réconcilier les mesures expérimentales

Les données d'usine pilote ne se ferment que rarement parfaitement en raison du bruit de mesure, des erreurs d'échantillonnage, des fuites, de la rétention et des pertes non mesurées.

Pour les mesures redondantes, formulez un problème de moindres carrés pondérés. Les poids peuvent refléter l'incertitude de mesure afin que les instruments les plus fiables influencent davantage la réconciliation.

Le résultat réconcilié doit être comparé aux mesures brutes plutôt que traité comme un remplacement de celles-ci.

Comprendre les compromis

La résolution directe est rapide mais suppose un modèle correct

np.linalg.solve() est efficace et précis pour un système linéaire, carré et bien conditionné.

Il ne peut pas corriger les spécifications manquantes, les signes de courant incorrects, les unités incohérentes ou les bilans mal sélectionnés.

Les vérifications de rang ne remplacent pas le jugement technique

Une matrice de plein rang confirme l'indépendance algébrique, pas la correction physique.

Un modèle peut être de plein rang tout en utilisant une composition erronée, un coefficient stoechiométrique incorrect ou une relation physique dupliquée exprimée de manière trompeuse.

Un mauvais conditionnement peut amplifier les erreurs de mesure

Même une matrice résoluble peut être mal conditionnée. De petites erreurs dans les débits ou compositions mesurés peuvent alors produire de grands changements dans les variables calculées.

Inspectez le nombre de conditionnement :

condition_number = np.linalg.cond(A)
print("Nombre de conditionnement :", condition_number)

Un nombre de conditionnement très élevé indique qu'une mise à l'échelle, de meilleures mesures, une reformulation ou une régularisation peuvent être nécessaires.

L'incohérence des unités corrompt silencieusement les résultats

Ne mélangez pas les kg/h, kmol/h, mol/s, lb/h ou les unités volumétriques sans conversion explicite.

Utilisez un système d'unités cohérent pour chaque bilan et appliquez les masses molaires lors de la conversion entre débit massique et molaire.

Comment appliquer cela à votre usine pilote

Un flux de travail fiable est :

Si votre objectif principal est un schéma de procédé linéaire entièrement spécifié : Définissez des bilans indépendants, assemblez A et b, vérifiez le rang et les résidus, et résolvez avec np.linalg.solve().
Si votre objectif principal est la réconciliation de données expérimentales : Incluez des mesures redondantes et utilisez np.linalg.lstsq() avec une pondération et une analyse des résidus appropriées.
Si votre objectif principal concerne les systèmes réactionnels : Identifiez les réactions indépendantes et utilisez les avancements de réaction avec des coefficients stoechiométriques pour éviter les variables redondantes.
Si votre objectif principal concerne le recyclage, l'équilibre ou le comportement cinétique : Utilisez la méthode matricielle pour les parties linéaires et scipy.optimize pour les équations non linéaires.
Si votre objectif principal est la validation de procédé : Vérifiez la conservation des composants, les débits non négatifs, les limites de composition, les unités et la concordance avec les données mesurées de l'usine pilote.

Avec une configuration disciplinée des équations et une validation physique, Python transforme les bilans complexes d'usines pilotes multi-composants en modèles de procédé transparents, testables et réutilisables.

Tableau récapitulatif :

Situation de modélisation	Méthode Python recommandée	Vérifications essentielles
Bilans linéaires entièrement spécifiés	`numpy.linalg.solve()`	Confirmer le plein rang, les unités cohérentes et les résidus proches de zéro
Système sous-déterminé	Ajouter des mesures ou spécifications indépendantes	Vérifier les degrés de liberté
Mesures surdéterminées ou bruitées	`numpy.linalg.lstsq()`	Examiner les résidus et appliquer une pondération de mesure
Réseaux de recyclage et de purge	Modèle matriciel global	Inclure les courants internes et les relations de recyclage
Réactions	Coefficients stoechiométriques et avancements de réaction indépendants	Vérifier la disponibilité des réactifs et la cohérence de la réaction
Équilibre, cinétique ou propriétés dépendantes du débit	`scipy.optimize.root()` ou autre solveur non linéaire	Utiliser de bonnes estimations initiales, une mise à l'échelle et des limites physiques
Données expérimentales d'usine pilote	Réconciliation par moindres carrés pondérés	Comparer les valeurs réconciliées avec les mesures brutes
Tout modèle de procédé	Vérifications indépendantes de conservation et de faisabilité	Vérifier les débits non négatifs, les compositions, les unités et les limites d'équipement

Besoin d'un moyen fiable pour modéliser votre usine pilote ? Contactez LABPARK pour discuter des unités pilotes d'opérations unitaires éducatives et professionnelles pour le génie chimique, les bioprocédés et la biotechnologie, ainsi que les applications de traitement de l'eau et de l'environnement. LABPARK aide les universités, les instituts de recherche et les entreprises à construire des plateformes de formation et de recherche pratiques avec des bilans de matière mesurables, des unités de procédé configurables, des réseaux de recyclage et d'utilités, et des données adaptées à la modélisation, à la validation et à l'optimisation des procédés basées sur Python. Dites-nous votre processus cible, vos objectifs d'enseignement ou de recherche, et l'échelle requise afin que nous puissions recommander une solution d'usine pilote adaptée à vos besoins.