Unifac Model

**app.
py**
from flask import Flask, render_template, request
import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt
import io
import base64
import time
app = Flask(__name__)
# Fonction pour calculer D_AB

def calculate_D_AB(Xa, a_AB, a_BA, λ_a, λ_b, q_a, q_b, D_AB0, D_BA0, T):
Xb = 1 - Xa # Fraction molaire de B
D = Xa * (D_BA0) + Xb * np.log(D_AB0) + \
2 * (Xa * np.log(Xa + (Xb * λ_b) / λ_a) +
Xb * np.log(Xb + (Xa * λ_a) / λ_b)) + \
2 * Xa * Xb * ((λ_a / (Xa * λ_a + Xb * λ_b)) * (1 - (λ_a / λ_b)) +
(λ_b / (Xa * λ_a + Xb * λ_b)) * (1 - (λ_b / λ_a))) + \
Xb * q_a * ((1 - ((Xb * q_b * np.exp(-a_BA / T)) / (Xa * q_a + Xb * q_b *
np.exp(-a_BA / T))) * 2) * (-a_BA / T) +
(1 - ((Xb * q_b) / (Xb * q_b + Xa * q_a * np.exp(-a_AB / T))) *
2) * np.exp(-a_AB / T) * (-a_AB / T)) + \
Xa * q_b * ((1 - ((Xa * q_a * np.exp(-a_AB / T)) / (Xa * q_a * np.exp(-a_AB
/ T) + Xb * q_b)) * 2) * (-a_AB / T) +
(1 - ((Xa * q_a) / (Xa * q_a + Xb * q_b * np.exp(-a_BA / T))) *
2) * np.exp(-a_BA / T) * (-a_BA / T))
# Calcul de D_AB
return np.exp(D)
# Fonction objectif pour la minimisation

def objective(params, Xa_values, D_AB_exp, λ_a, λ_b, q_a, q_b, D_AB0, D_BA0, T):
a_AB, a_BA = params
D_AB_calculated = calculate_D_AB(Xa_values, a_AB, a_BA, λ_a, λ_b, q_a, q_b,
D_AB0, D_BA0, T)
return np.sum((D_AB_calculated - D_AB_exp)**2)
@app.route('/')
def input_data():
return render_template('index.html')
@app.route('/calculate', methods=['POST'])
def calculate():
if request.method == 'POST':
try:
D_AB_exp = float(request.form['D_AB_exp'])
T = float(request.form['T'])
Xa = float(request.form['Xa'])
λ_a = eval(request.form['λ_a'])
λ_b = eval(request.form['λ_b'])
q_a = float(request.form['q_a'])
q_b = float(request.form['q_b'])
D_AB0 = float(request.form['D_AB0'])
D_BA0 = float(request.form['D_BA0'])
# Paramètres initiaux
params_initial = [0, 0]
# Tolerance
tolerance = 1e-12
# Nombre maximal d'itérations

max_iterations = 1000
iteration = 0
# Temps de départ
start_time = time.time()
# Boucle d'ajustement des paramètres

while iteration < max_iterations:
# Minimisation de l'erreur
result = minimize(objective, params_initial, args=(Xa, D_AB_exp,
λ_a, λ_b, q_a, q_b, D_AB0, D_BA0, T), method='Nelder-Mead')
# Paramètres optimisés
a_AB_opt, a_BA_opt = result.x
# Calcul de D_AB avec les paramètres optimisés

D_AB_opt = calculate_D_AB(Xa, a_AB_opt, a_BA_opt, λ_a, λ_b, q_a,
q_b, D_AB0, D_BA0, T)
# Calcul de l'erreur
error = np.abs(D_AB_opt - D_AB_exp)
# Vérifier si la différence entre les paramètres optimisés est

inférieure à la tolérance
if np.max(np.abs(np.array(params_initial) - np.array([a_AB_opt,
a_BA_opt]))) < tolerance:
break
# Mise à jour des paramètres initiaux

params_initial = [a_AB_opt, a_BA_opt]
# Incrémentation du nombre d'itérations

iteration += 1
# Temps d'exécution
execution_time = time.time() - start_time
# Générer la courbe
Xa_values = np.linspace(0, 0.7, 100) # Fraction molaire de A
D_AB_values = calculate_D_AB(Xa_values, a_AB_opt, a_BA_opt, λ_a, λ_b,
q_a, q_b, D_AB0, D_BA0, T)
plt.plot(Xa_values, D_AB_values)
plt.xlabel('Fraction molaire de A')
plt.ylabel('Coefficient de diffusion (cm^2/s)')
plt.title('Variation du coefficient de diffusion en fonction du
fraction molaire')
plt.grid(True)
# Convertir le graphique en une représentation base64

buffer = io.BytesIO()
plt.savefig(buffer, format='png')
buffer.seek(0)
graph = base64.b64encode(buffer.getvalue()).decode()
plt.close()
# Affichage des résultats
return render_template('result.html', a_AB_opt=a_AB_opt,
a_BA_opt=a_BA_opt, D_AB_opt=D_AB_opt, error=error, iteration=iteration,
execution_time=execution_time, graph=graph)
except Exception as e:
return f"Une erreur s'est produite : {e}"
if __name__ == '__main__':
app.run(debug=True)
**Index.html**
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Entrée des données</title>
<style>
body {
font-family: Arial, sans-serif;
background-color: #FAF3DD; /* Couleur beige */
padding: 20px;
}
.container {
max-width: 600px;
margin: auto;
background-color: #FFFFFF; /* Couleur blanche pour le conteneur */
padding: 20px;
border-radius: 8px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1); /* Ombre légère */
border: 2px solid #000000; /* Cadre noir */
}
.input-group {
margin-bottom: 15px;
}
.input-group label {
display: block;
margin-bottom: 5px;
font-weight: bold;
}
.input-group input {
width: 100%;
padding: 8px; /* Taille réduite des padding */
border: 1px solid #ccc;
border-radius: 4px;
font-size: 16px;
}
.input-group button {
padding: 10px 15px;
background-color: #FFA62B; /* Couleur orange */
color: #FFFFFF;
border: none;
border-radius: 4px;
cursor: pointer;
font-size: 16px;
}
.input-group button:hover {
background-color: #FF8C00; /* Couleur orange foncé au survol */
}
</style>
</head>
<body>
</style>
</head>
<body>
<div class="container">
<h2>Entrée des données</h2>
<form action="/calculate" method="post">
<div class="input-group">
<label for="D_AB_exp">D_AB_exp:</label>
<input type="text" id="D_AB_exp" name="D_AB_exp" required>
</div>
<label for="T">T:</label>
<input type="text" id="T" name="T" required>
</div>
<label for="Xa">Xa:</label>
<input type="text" id="Xa" name="Xa" required>
</div>
<label for="λ_a">λ_a:</label>
<input type="text" id="λ_a" name="λ_a" required>
</div>
<label for="λ_b">λ_b:</label>
<input type="text" id="λ_b" name="λ_b" required>
</div>
<label for="q_a">q_a:</label>
<input type="text" id="q_a" name="q_a" required>
</div>
<label for="q_b">q_b:</label>
<input type="text" id="q_b" name="q_b" required>
</div>
<label for="D_AB0">D_AB0:</label>
<input type="text" id="D_AB0" name="D_AB0" required>
</div>
<label for="D_BA0">D_BA0:</label>
<input type="text" id="D_BA0" name="D_BA0" required>
</div>
<button type="submit">Calculer</button>
</div>
</form>
</div>
</body>
</html>
**Resultat.html**
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Résultat du calcul</title>
<style>
body {
font-family: Arial, sans-serif;
background-color: #FAF3DD; /* Couleur beige */
padding: 20px;
}
.container {
max-width: 800px;
margin: auto;
background-color: #FFFFFF; /* Couleur blanche pour le conteneur */
padding: 20px;
border-radius: 8px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1); /* Ombre légère */
border: 2px solid #000000; /* Cadre noir */
}
.result-table {
width: 100%;
border-collapse: collapse;
margin-top: 20px;
}
.result-table th, .result-table td {
border: 1px solid #000000; /* Bordure noire */
padding: 10px;
text-align: left;
}
.result-table th {
background-color: #FFA62B; /* Couleur orange pour l'en-tête */
color: #FFFFFF;
}
.graph {
max-width: 600px;
margin-top: 20px;
}
</style>
</head>
<body>
<div class="container">
<h2>Résultat du calcul</h2>
<table class="result-table">
<tr>
<th>Paramètre</th>
<th>Valeur</th>
</tr>
<tr>
<td>Paramètre a_AB optimisé:</td>
<td>{{ a_AB_opt }}</td>
</tr>
<tr>
<td>Paramètre a_BA optimisé:</td>
<td>{{ a_BA_opt }}</td>
</tr>
<tr>
<td>D_AB calculé:</td>
<td>{{ D_AB_opt }}</td>
</tr>
<tr>
<td>Erreur:</td>
<td>{{ error }}</td>
</tr>
<tr>
<td>Nombre d'itérations:</td>
<td>{{ iteration }}</td>
</tr>
<tr>
<td>Temps d'exécution:</td>
<td>{{ execution_time }} secondes</td>
</tr>
</table>
<div class="graph">
<img src="data:image/png;base64,{{ graph }}" alt="Graphique">
</div>
</div>
</body>
</html>

Unifac Model

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Unifac Model

Transféré par

Droits d'auteur :

Formats disponibles

**app.

# Fonction pour calculer D_AB

# Fonction objectif pour la minimisation

# Nombre maximal d'itérations

# Boucle d'ajustement des paramètres

# Calcul de D_AB avec les paramètres optimisés

# Vérifier si la différence entre les paramètres optimisés est

# Mise à jour des paramètres initiaux

# Incrémentation du nombre d'itérations

# Convertir le graphique en une représentation base64

Vous aimerez peut-être aussi