Pilotefrigo NNVolum DP
Pilotefrigo NNVolum DP
Pilotefrigo NNVolum DP
NON NOMINAL
SOMMAIRE
© R. GICQUEL 2009. Toute représentation ou reproduction intégrale ou partielle faite sans autorisation est
illicite, et constitue une contrefaçon sanctionnée par le Code de la propriété intellectuelle.
Avertissement : les informations contenues dans ce document peuvent faire l'objet de modifications sans
préavis, et n'ont en aucune manière un caractère contractuel.
1 Introduction - pré-requis
L'objectif de cette notice est de permettre à un développeur de se familiariser avec l'écriture d'un pilote pour
l'étude en régime non-nominal d'un cycle frigorifique avec Thermoptim. Nous faisons l'hypothèse que vous
connaissez déjà bien Thermoptim et son mécanisme de classes externes, et que vous avez pris connaissance de
l'ensemble des quatre tomes du manuel de référence du progiciel. Nous vous conseillons par ailleurs de vous
référer au tome 3 du livre Systèmes Energétiques1 pour de plus amples développements sur la problématique du
dimensionnement technologique et du non-nominal.
Le dimensionnement technologique des composants nécessite d'affiner les modèles phénoménologiques utilisés
dans le noyau de Thermoptim, en les complétant pour prendre en compte les mécanismes de fonctionnement à
charge partielle s'il en existe. Le progiciel a pour cela été doté de nouveaux écrans, dits de dimensionnement
technologique, qui permettent de définir les caractéristiques géométriques représentatives des différentes
technologies utilisées, ainsi que les paramètres nécessaires pour le calcul de leurs performances.
Ce nouvel environnement, développé sous forme de classes externes, doit pouvoir travailler de manière à la fois
complémentaire de celle des composants du noyau, et en même temps parfaitement cohérente avec eux. Selon
les moments, les calculs sont en effet soit effectués par le noyau du progiciel, soit réalisés par les classes de
dimensionnement technologique, le pilote assurant la synchronisation entre les deux modes.
& c p ) min
(m
R= ≤1 (2)
& c p ) max
(m
∆Tmax
L'efficacité de l'échangeur vaut : ε = (3)
∆Te
Avec ces définitions, il est possible de montrer qu’il existe une relation générale du type :
En mode dimensionnement, on connaît les débits des deux fluides, leurs températures d'entrée et le flux à
échanger, on opère de la manière suivante :
• on commence par déterminer les températures de sortie des fluides ;
·
• on en déduit les débits de capacité thermique m cp des fluides et leur rapport R ;
• on calcule l’efficacité ε à partir de l'équation (3) ;
• on détermine la valeur du NUT à partir de la relation (NUT, ε) appropriée ;
• on calcule le produit UA à partir de l’équation (1).
1
GICQUEL R., Systèmes Energétiques, Tome 3 : cycles et modélisations avancés, systèmes innovants a faible
impact environnemental, Presses de l'Ecole des Mines de Paris, janvier 2009.
En régime non-nominal, on connaît les températures d'entrée et les débits des deux fluides, la surface A de
l'échangeur et sa géométrie (configurations d'écoulement et paramètres technologiques). Le calcul se fait alors en
trois étapes :
• détermination de U par des corrélations dépendant de la configuration d'écoulement et de la géométrie de
l'échangeur ;
• calcul de UA, produit de U et de A, puis de NUT par (1) ;
• détermination de l'efficacité de l'échangeur par la relation (NUT, ε) appropriée, et calcul des températures de
sortie par (3) et les équations de bilan.
Connaissant Tce, Tfe, mc, mf et U, il est ainsi possible de calculer R, puis NUT, d'en déduire ε, et de déterminer
les températures de sortie Tcs et Tfs.
Rappelons que la méthode du NUT fait l'hypothèse que les propriétés thermophysiques du fluide sont constantes
dans l'échangeur, alors que ce n'est vrai qu'en première approximation. Si on considère U variable, dépendant
comme c'est le cas aussi bien des températures d'entrée que des températures de sortie, on obtient un système
d'équations implicite très difficile à résoudre, surtout si les échangeurs sont multizones comme pour les
évaporateurs ou condenseurs.
En pratique, on peut cependant souvent considérer que U ne varie qu'au deuxième ordre, et rechercher une
solution approchée en considérant U constant, puis recalculer sa valeur pour les nouvelles conditions de
fonctionnement, et itérer jusqu'à obtenir une précision raisonnable. Il est en particulier nécessaire d'opérer ainsi
lorsque l'échangeur est multizones, car seule la surface totale est connue, et non sa répartition entre les
différentes zones. C'est précisément comme cela que nous opérerons.
Les calculs dans le simulateur sont donc effectués en appliquant la méthode du NUT, le UA étant une inconnue
intermédiaire, tandis que les calculs dans les écrans technologiques se font de manière détaillée, conduisant, pour
un jeu des valeurs d'entrée-sortie de l'échangeur donné et compte tenu de la valeur de U correspondante, à une
estimation de la surface requise. La cohérence entre les deux calculs est assurée lorsque la valeur du UA est telle
que la surface totale d'échange est égale à celle de dimensionnement.
Un compresseur volumétrique est défini géométriquement par sa cylindrée et les paramètres technologiques
permettant de calculer ses rendements volumétrique et isentropique, en fonction de sa vitesse de rotation et des
conditions d'aspiration et de refoulement
Les modèles implémentés dans Thermoptim sont de ce fait basés sur l'hypothèse que le comportement des
compresseurs volumétriques peut être représenté avec une précision raisonnable par deux grandeurs : leur rende-
ment volumétrique λ qui caractérise le volume balayé réel (4), et leur rendement isentropique classique ηs (5).
λ =a −a Pref
0 1 (4)
Pasp
2
Pasp Pasp
η s = K1 + K 2 ⋅ + K3⋅ (5)
Pref Pref
On notera que (5) s'exprime linéairement en fonction de l'inverse du rapport de compression et de son carré.
·
· V λ N Vs
m= = (7)
v 60 v
En régime non-nominal, le rapport de compression détermine λ et ηs, ce qui fixe le débit et la température de
sortie compresseur.
La surchauffe à l'évaporation ∆Tsurch vaut 5 K, ce qui pour un débit de réfrigérant de 0,955 kg/s fixe la puissance
frigorifique à environ 131 kW. Avec un débit d'eau glycolée de 15 kg/s, cela conduit à un refroidissement de
2,42 °C.
Pour le condenseur, la température de l'air vaut 30 °C, et son débit 25 kg/s. La température de condensation est
estimée à 42 °C, ce qui, avec un sous-refroidissement initial ∆Tssrefr de 5 K, correspond à une pression de
condensation d'environ 10,9 bars. Le COP de la machine vaut dans ces conditions 2,24.
La prise en compte des pertes de charge du réfrigérant demande quelques précautions pour éviter des difficultés
de calcul dans les phases de condensation et d'évaporation. Nous avons choisi de les affecter uniquement aux
points dont l'état est monophasique : en totalité en aval de l'évaporateur, et pour moitié en amont et en aval du
condenseur.
Les pertes de charge sur l'air et l'eau glycolée sont calculées dans les écrans technologiques des échangeurs, puis
affectées comme surpression à réaliser en amont de l'échangeur. Les ventilateurs et la pompe à eau glycolée sont
ici modélisés par des transfos compression classiques, sans prise en compte de leurs caractéristiques détaillées. Il
serait possible de le faire, mais au prix d'une complexité accrue qui n'apparaît pas vraiment justifiée.
Le dimensionnement se fait en deux étapes distinctes, la première correspond au paramétrage classique du cycle
dans Thermoptim, tandis que la seconde est effectuée à partir des écrans technologiques. Précisons, et ceci est
très important, que la deuxième étape ne peut être effectuée que lorsque la première a été menée à son terme et a
permis d'obtenir un modèle parfaitement cohérent. Si ce n'est pas le cas, le dimensionnement technologique
effectué au cours de la seconde étape risque d'être aberrant et d'entraîner de grandes difficultés de convergence.
Nous ne détaillerons pas ici, pour simplifier les choses, la manière de construire le modèle Thermoptim du cycle
correspondant à la première étape. S'il n'existait pas, il faudrait d'abord le faire, puis la méthode serait la même.
Ce cycle de réfrigération est semblable à ceux qui ont été présentés dans les guides de prise en mains du
progiciel, la différence principale étant que le condenseur est modélisé par un seul échangeur multizone, la
désurchauffe n'étant pas dissociée dans l'éditeur de schémas de la condensation proprement dite.
La création des écrans technologiques peut être effectuée en utilisant soit le pilote générique, soit un pilote
particulier, ce qui est nécessaire lorsque l'on veut faire des simulations en régime non-nominal comme c'est le
cas ici.
Dans cet exemple, ces écrans sont créés de la manière suivante : la première étape dans la construction du pilote
est celle de l'instanciation d'une part des différents PointThopt2 qui vont permettre d'accéder aux points du
simulateur (un pour chaque point du cycle), et d'autre part des TechnoDesign.
amontEvap=new PointThopt(proj,"4");
avalEvap=new PointThopt(proj,"1");
amontCond=new PointThopt(proj,"2");
avalCond=new PointThopt(proj,"3");
waterInlet=new PointThopt(proj,"water inlet");
waterOutlet=new PointThopt(proj,"water outlet");
inAir=new PointThopt(proj,"air inlet");
outAir=new PointThopt(proj,"air outlet");
avalCond.getProperties();
refrig=(rg.corps.Corps)avalCond.lecorps;
evaporatorName="evaporator";
condenserName="condenser";
compressorName="compressor";
La dernière ligne du code ci-dessus permet de transférer ces écrans technologiques dans le noyau du progiciel.
Les valeurs de la cylindrée et de la vitesse de rotation du TechnoDesign sont alors affichées à l'écran.
2
Cette classe permet de créer dans une classe externe des sortes de clones des points du noyau de Thermoptim,
afin d'avoir un accès aisé à leurs valeurs, qui ne sont pas directement accessibles. Elle apporte davantage de
confort et de lisibilité que ne le fait l'utilisation des méthodes getProperties() et updatePoint de Projet,
documentées dans le tome 3 du manuel de référence.
VsValue=Util.lit_d(technoCompr.Vs_value.getText());
Vs_value.setText(Util.aff_d(VsValue,8));
N_value=Util.lit_d(technoCompr.N_value.getText());
Nref_value.setText(Util.aff_d(N_value,4));
Commencez par cliquer sur "Initial settings" pour instancier les TechnoDesign et effectuer un premier
dimensionnement technologique, en l'occurrence calculer la vitesse de rotation ou la cylindrée du compresseur
ainsi que les surfaces des deux échangeurs correspondant au paramétrage du fichier de projet, sur la base des
valeurs par défaut des paramètres des TechnoDesign.
3.3.1 Evaporateur
Figure 3 : Ecran de dimensionnement de l'évaporateur
On considère que l'évaporateur
est du type tubes et calandre et qu'il a côté eau une section de passage du fluide de 8 dm2 et un diamètre
hydraulique de 1 cm, et côté réfrigérant une section de passage de 2 dm2 et un diamètre hydraulique de 1 cm,
pour une longueur de tubes de 3 m. Choisissez le type de configuration ("evap Gungor Winterton" pour
évaporation à l'intérieur des tubes pour la partie "évaporateur" (le frigorigène), et "ext tube Colburn correlation"
pour l'eau glycolée, et paramétrez l'écran comme indiqué figure 3.
3.3.2 Condenseur
Choisissez le type de
configuration ("cond Shah
correlation" pour la
condensation à l'intérieur des
tubes pour la partie
"condenseur" (le frigorigène), Figure 4 : Ecran de dimensionnement du condenseur
et "air coil Morizot correlation" pour l'air, et paramétrez l'écran comme indiqué figure 4.
3.3.3 Compresseur
Les résultats sont affichés dans les écrans Figure 5 : Ecran de dimensionnement du compresseur
technologiques : surfaces d'échanges de 25 m2 pour
l'évaporateur et le condenseur ; vitesse de rotation de 1500 tr/mn et cylindrée d'environ 0,01 m3 pour le
compresseur.
Divers résultats de calcul sont affichés sur les écrans technologiques, comme, pour les échangeurs, les pertes de
charge et les valeurs du nombre de Reynolds Re et des coefficients d'échange locaux.
Le paramétrage des écrans technologiques permet de déterminer les surfaces d'échange, la masse totale de
réfrigérant et la vitesse de rotation du compresseur, à partir des initialisations correspondant au point nominal,
qui servent à fixer un certain nombre de valeurs à partir de celles du projet Thermoptim, comme les ∆T de
surchauffe et de sous-refroidissement initial.
Le calcul précis des échangeurs multizones est quant à lui effectué par la méthode makeDesign() des
TechnoDesign des échangeurs, alors que la valeur globale de UA est obtenue de manière classique, grâce aux
modèles phénoménologiques.
Les premières lignes du code permettent, en utilisant la méthode getProperties() du projet de Thermoptim (proj),
connaissant le nom de l'échangeur (condenserName), de récupérer la valeur de UAcond et le nom du fluide froid,
puis l'enthalpie mise en jeu DeltaH.
if(!condenserName.equals("")){//initialisation du Condenseur
String[] args=new String[2];
args[0]="heatEx";
args[1]=condenserName;
Vector vProp=proj.getProperties(args);
Double f=(Double)vProp.elementAt(15);
UAcond=f.doubleValue();
String fluideFroid=(String)vProp.elementAt(1);
args[0]="process";
args[1]=fluideFroid;
vProp=proj.getProperties(args);
f=(Double)vProp.elementAt(4);
double DeltaH=f.doubleValue();
Les méthodes getProperties() des PointThopt fournissent directement l'état thermodynamique complet des points
amont et aval du condenseur, ce qui permet d'initialiser le sous-refroidissement.
avalCond.getProperties();
amontCond.getProperties();
DTssrefr=avalCond.DTsat;
De la même manière, la valeur de la température de l'air est obtenue du simulateur et affichée dans l'écran du
pilote.
inAir.getProperties();
outAir.getProperties();
Tair=inAir.T;
Ta_value.setText(Util.aff_d(Tair-273.15,4));
Ces valeurs permettent d'initialiser les valeurs des débits calorifiques du condenseur, qui seront utilisées
ultérieurement.
mCpCalopCond=DeltaH/(outAir.T-outFanAir.T);
mCpRefrigCond=DeltaH/(amontCond.T-avalCond.T);
UAcond_value.setText(Util.aff_d(UAcond,4));
Le TechnoDesign est alors initialisé à son tour, ce qui permet de connaître la surface d'échange nécessaire
compte tenu du dimensionnement réalisé, puis les pertes de charge sont mises à jour.
//initialisations du TechnoDesign
technoCond.makeDesign();
AcondReel=Util.lit_d(technoCond.ADesign_value.getText());
AcalculatedCond_value.setText(technoCond.ADesign_value.getText());
La charge initiale de frigorigène est alors calculée compte tenu des dimensions géométriques et de l'état
thermodynamique du fluide.
lineLength=Util.lit_d(lineLength_value.getText());
double dh=Util.lit_d(technoCond.techc.Dh_value.getText());
volLigne=Math.PI*dh*dh/4.*lineLength;
mLigne=volLigne/avalCond.V;
mLine_value.setText(Util.aff_d(mLigne,4));
mTot=mCond+mEvap+mLigne;
mTot_value.setText(Util.aff_d(mTot,4));
}
if(!compressorName.equals("")){//initialisation du compresseur
String[] args=new String[2];
args[0]="process";
args[1]=compressorName;
Vector vProp=proj.getProperties(args);
String amont=(String)vProp.elementAt(1);
String aval=(String)vProp.elementAt(2);
Double f=(Double)vProp.elementAt(3);
massFlow=f.doubleValue();
lambdaVol=technoCompr.getLambdaVol();
if(!jCheckVs.isSelected()){//calcul de la vitesse de rotation
N_value=massFlow*60*avalEvap.V/VsValue/lambdaVol;
technoCompr.setN(N_value);
Nref_value.setText(Util.aff_d(N_value,4));
}
else{//calcul de la cylindrée
N_value=Util.lit_d(Nref_value.getText());
technoCompr.setN(N_value);
VsValue=massFlow*60*avalEvap.V/N_value/lambdaVol;
technoCompr.setVs(VsValue);
Vs_value.setText(Util.aff_d(VsValue,8));
}
}
outFanAir.P=inAir.P+dPair;
outFanAir.update(!UPDATE_T,UPDATE_P,!UPDATE_X);
updateprocess(fanName, "Compression",RECALCULATE,!IS_SET_FLOW, !UPDATE_FLOW, 0,
!UPDATE_ETA, 0);
outFanAir.getProperties();
waterPumpOutlet.P=waterInlet.P+dPwater;
waterPumpOutlet.update(!UPDATE_T,UPDATE_P,!UPDATE_X);
updateprocess(pumpName, "Compression",RECALCULATE,!IS_SET_FLOW, !UPDATE_FLOW, 0,
!UPDATE_ETA, 0);
waterPumpOutlet.getProperties();
Dans toute étude de comportement en régime non-nominal, il faut bien identifier quelles sont les variables
indépendantes du système considéré, en les distinguant des variables liées qui s'en déduisent.
Dans cet exemple, il s'agit du quadruplet (débit de réfrigérant, température d'évaporation, température de
condensation, sous-refroidissement), les variables liées étant les pressions du fluide et les puissances thermiques
et mécaniques mises en jeu. A ces quatre variables "naturelles" , il faut ajouter les deux variables intermédiaires
UAevap et UAcond (cf. section 2.1).
La recherche de ce sextuplet correspond à celle de la solution d'un jeu d'équations non linéaires relativement
complexe qui met en jeu celles que nous venons de présenter et d'autres qui seront détaillées section 6.
La solution que nous avons retenue consiste à programmer un pilote externe qui assure la résolution de ce
système d'équations et met à jour Thermoptim une fois la solution trouvée.
Nous utilisons la méthode de Levendberg-Marquardt correspondant aux algorithmes mis au point en Fortran
sous le nom de minPack 1, et traduits sous Java. Cette méthode combine l'algorithme de Gauss-Newton et la
méthode de descente de gradient. Son intérêt principal est d'être très robuste et de ne nécessiter comme
initialisation qu'une solution approchée.
Son implémentation sous Java se fait en utilisant une interface appelée optimization.Lmdif_fcn, qui contraint les
classes appelantes (ici notre pilote) à disposer d'une fonction appelée fcn().
Cette fonction fcn() reçoit comme principaux arguments un vecteur (tableau x[n])3 contenant les variables et un
vecteur (tableau fvec[m]) renvoyant les résidus des fonctions que l'on cherche à annuler. Leur nombre peut
excéder celui des variables, mais dans notre cas il sera le même.
Le guidage de l'algorithme se fait en pratique en jouant sur deux critères de précision, l'un portant sur la somme
des résidus, et l'autre sur la précision du calcul des dérivées partielles, estimées par différences finies. N'oublions
pas que nous cherchons à résoudre un système de six équations non linéaires à six inconnues, ce qui peut se
révéler numériquement difficile. A l'usage, il est apparu intéressant de proposer plusieurs options de calcul.
Tout d'abord, l'option "reinitialize" offre la possibilité de réinitialiser les valeurs des températures d'évaporation
et de condensation en fonction de celles de l'eau glycolée et de l'air ambiant, pour éviter tout croisement de
température dans les échangeurs.
Ensuite, deux options exclusives sont proposées : soit exécuter l'algorithme en une seule étape, pour des valeurs
intermédiaires de précision des critères de convergence ("one step algorithm"), soit l'exécuter en deux étapes, la
première permettant une convergence grossière, et la seconde plus précise ("two steps algorithm").
Selon les cas, l'utilisateur pourra opter pour l'une ou l'autre, en fonction des difficultés numériques rencontrées.
Un indicateur de précision, correspondant à la norme L2 des résidus, est affiché dans la partie résultat de l'écran
du pilote (figure 6).
S'il lance les calculs depuis l'écran général des écrans technologiques, l'utilisateur peut de surcroît s'il le désire
interrompre les calculs proprement en cliquant sur le bouton "Stop", ce qui lui permet de changer d'option.
Attention toutefois, car cette manière d'opérer peut conduire à des erreurs.
3
Attention : afin de conserver les mêmes indices qu'en Fortran, l'implémentation Java déclare des tableaux de
dimension n+1 au lieu de n, l'indice 0 n'étant pas utilisé
x[1] = Tcond;
x[2] = Tevap;
x[3] = massFlow;
x[4] = UAevap;
x[5] = UAcond;
x[6] = DTssrefr;
Les initialisations se font sur la base des valeurs affichées dans l'écran du pilote, pour les surfaces d'échange de
l'évaporateur et du condenseur, la vitesse de rotation et la cylindrée du compresseur, ainsi que la température
extérieure. Les autres valeurs sont celles des écrans du simulateur.
//lecture à l'écran du pilote des paramètres et variables, éventuellement modifiés après initialisation
AdesignEvap=Util.lit_d(AdesignEvap_value.getText());//surface de l'évaporateur
AdesignCond=Util.lit_d(AdesignCond_value.getText());//surface du condenseur
Tair=Util.lit_d(Ta_value.getText())+273.15;
inAir.T=Tair;
inAir.update(UPDATE_T,!UPDATE_P,!UPDATE_X);
inAir.getProperties();
amontEvap.getProperties();
avalEvap.getProperties();
amontCond.getProperties();
avalCond.getProperties();
DTsurch=avalEvap.DTsat;
DTssrefr=avalCond.DTsat;
algorithmResults.setText("");
Comme indiqué plus haut, selon que l'on coche ou non l'option "reinitialize", les temperatures de changement
d'état sont celles du simulateur ou déterminées à partir des températures du caloporteur (air) et du frigoporteur
(eau glycolée). Ces initialisations permettent notamment d'éviter des inversions de température dans les
échangeurs lorsque la recherche se fait loin de l'état de départ.
L'appel à l'algorithme de résolution se fait, une fois qu'il est initialisé, par :
int m = 6; int n = 6;
x[1] = Tcond;
x[2] = Tevap;
x[3] = massFlow;
x[4] = UAevap;
x[5] = UAcond;
x[6] = DTssrefr;
double residu0;
double residu1;
fcn(m,n,x,fvec,iflag);
residu0 = optimization.Minpack_f77.enorm_f77(m,fvec);
nfev2 = 0; njev2 = 0;
if(twoStepAlgorithm.isSelected()){
epsi=0.01;
}
//appel modifié de lmdiff avec modification précision calcul des différences finies
optimization.Minpack_f77.lmdif2_f77(this, m, n, x, fvec, epsi, epsfcn, info);
residu1 = optimization.Minpack_f77.enorm_f77(m,fvec);
if(twoStepAlgorithm.isSelected()){
epsi=0.00005;
epsfcn = 1.e-9;//précision calcul des différences finies
//appel modifié de lmdiff avec modification précision calcul des différences finies
optimization.Minpack_f77.lmdif2_f77(this, m, n, x, fvec, epsi, epsfcn, info);
residu1 = optimization.Minpack_f77.enorm_f77(m,fvec);
}
Pour pouvoir estimer les résidus, il faut, comme le montre le code ci-dessous, commencer par d'une part mettre à
jour les variables de Thermoptim correspondant au vecteur x, et d'autre part calculer les variables liées.
Comme indiqué dans fcn(), les fonctions fvec sont six méthodes resEvap(), recCond et resFlow(), resAevap(),
resAcond() et resLoad() définies ci-dessous.
L'appel aux trois premières se fait avant recalcul du simulateur et des TechnoDesign, et celui aux autres ensuite.
public void fcn(int m, int n, double x[], double fvec[], int iflag[]) {
if (iflag[1]==1) this.nfev++;
if (iflag[1]==2) this.njev++;
//mise à jour des variables "physiques" pour une meilleure compréhension du code
Tcond=x[1];
Tevap=x[2];
massFlow=x[3];
UAevap=x[4];
UAcond=x[5];
DTssrefr=x[6];
La première étape consiste à mettre à jour tous les points et transfos du modèle pour que les calculs des résidus
soient effectués sur la base des valeurs du vecteur x. Les pertes de charge sont affectées pour moitié au point
amont et pour moitié au point aval du condenseur, et pour totalité de l'évaporateur.
Une fois ces mises à jour effectuées, les trois premiers résidus correspondant à l'équilibrage du cycle de
réfrigération sont calculés.
Le cycle étant équilibré, le projet est recalculé un certain nombre de fois, ainsi que les échangeurs :
amontEvap.getProperties();
avalEvap.getProperties();
amontCond.getProperties();
avalCond.getProperties();
waterInlet.getProperties();
waterOutlet.getProperties();
inAir.getProperties();
outAir.getProperties();
outFanAir.P=inAir.P+dPair;
outFanAir.update(!UPDATE_T,UPDATE_P,!UPDATE_X);
updateprocess(fanName, "Compression",RECALCULATE,!IS_SET_FLOW, !UPDATE_FLOW, 0,
!UPDATE_ETA, 0);
outFanAir.getProperties();
waterPumpOutlet.P=waterInlet.P+dPwater;
waterPumpOutlet.update(!UPDATE_T,UPDATE_P,!UPDATE_X);
updateprocess(pumpName, "Compression",RECALCULATE,!IS_SET_FLOW, !UPDATE_FLOW, 0,
!UPDATE_ETA, 0);
waterPumpOutlet.getProperties();
Les TechnoDesign des échangeurs sont alors recalculés, ce qui met à jour les pertes de charge et permet
d'estimer les surfaces d'échange et la charge de frigorigène correspondant à ce nouvel état :
technoEvap.makeDesign();
technoCond.makeDesign();
AcalculatedEvap_value.setText(technoEvap.ADesign_value.getText());
AcalculatedCond_value.setText(technoCond.ADesign_value.getText());
return;
}
Nous nous contenterons ici de donner deux exemples de résidus, relatifs à l'équilibrage du condenseur et au
calcul de sa surface d'échange. Les autres sont présentés section 6. Dans les deux cas, le résidu a été normé pour
équilibrer les poids des différentes fonctions d'écart, en utilisant une méthode simple, mais valable uniquement si
la valeur à atteindre n'est pas nulle, ce qui est toujours le cas ici.
mCpRefrigCond=DeltaHcond/(amontCond.T-(Tcond+DTssrefr));
double[]res=Util.epsi_NUT(mCpRefrigCond,mCpCalopCond,UAcond);
epsilon=res[0];
mCpmin=res[1];
double Tentree_refrig=outFanAir.T+DeltaHcond/epsilon/mCpmin;
double Tsortie_refrig=Tentree_refrig-DeltaHcond/mCpRefrigCond;
z= 2*z/(AcondReel+AdesignCond);
return z;
}
La précision de la solution est écrite dans le fichier texte "output.txt", et l'écran du pilote est mis à jour.
System.out.println();
System.out.println(" Initial L2 norm of the residuals: " + residu0);
System.out.println("Final L2 norm of the residuals: " + residu1);
System.out.println("Number of function evaluations: " + nfev);
System.out.println("Number of Jacobian evaluations: " + njev);
System.out.println("Info value: " + info[1]);
System.out.println("Final approximate solution: " + x[1] + ", " + x[2]+ ", " + x[3] );
System.out.println(); /**/
UAevap_value.setText(Util.aff_d(UAevap,4));
UAcond_value.setText(Util.aff_d(UAcond,4));
AcalculatedEvap_value.setText(technoEvap.ADesign_value.getText());
AcalculatedCond_value.setText(technoCond.ADesign_value.getText());
COP_value.setText(Util.aff_d(DeltaHevap/tauCompr,4));
DeltaHevap_value.setText(Util.aff_d(DeltaHevap,4));
massFlow_value.setText(Util.aff_d(massFlow,4));
DeltaHcond_value.setText(Util.aff_d(DeltaHcond,4));
Pevap_value.setText(Util.aff_d(Pevap,4));
Pcond_value.setText(Util.aff_d(avalCond.P,4));
tauCompr_value.setText(Util.aff_d(tauCompr,4));
La température d'évaporation est fixée par l'équilibre thermique de l'évaporateur, lequel dépend essentiellement
d'une part de la température Tf et du débit du frigoporteur (eau glycolée dans cet exemple), et d'autre part du
débit de frigorigène.
·
∆Hevap = m (h(Te+ ∆Tsurch, Pe) - h(Tc- ∆Tssrefr, Pc)) = Ue Ae ∆Tml_ef (8)
mCpRefrigEvap=DeltaHevap/DTsurch;
double[]res=Util.epsi_NUT(mCpRefrigEvap,mCpCalopEvap,UAevap);
epsilon=res[0];
mCpmin=res[1];
double z=Tevap-waterPumpOutlet.T+DeltaHevap/epsilon/mCpmin;//résidu
z= 2*z/(Tevap+Tf-DeltaHevap/epsilon/mCpmin);
return z;
}
Le bilan du compresseur exprime que le travail de compression est égal au produit du débit par le travail
massique de compression isentropique, divisé par le rendement isentropique. Il dépend lui aussi de plusieurs
grandeurs et est donné par :
· ∆hs (Te,Pe,Pc)
τ=m (9)
ηs (Pc/Pe)
// recalcul du compresseur
double eta_is=technoCompr.getRisentr();
updateprocess(compressorName, "Compression",RECALCULATE,IS_SET_FLOW, UPDATE_FLOW,
massFlow, UPDATE_ETA, eta_is);
amontCond.getProperties();
return tauCompr;
}
De manière analogue à ce que nous avons exposé pour l'évaporateur, la température de condensation est fixée
par l'équilibre thermique du condenseur, lequel dépend essentiellement d'une part de la température et du débit
de l'air de refroidissement, d'autre part du débit de frigorigène, et enfin de la température de sortie condenseur.
La résolution de l'équation (7) se fait en comparant la valeur qu'elle fournit (implémentée dans le TechnoDesign
du compresseur) avec celle de massFlow = x[3]. Le calcul de λ est fait dans le TechnoDesign.
·
· V λ N Vs
m= = (7)
v 60 v
Vevap=avalEvap.V;
double rCompr=amontCond.P/avalEvap.P;
double y=technoCompr.getMassFlow(Vevap, rCompr);
double z= massFlow-y;
z= 2*z/(massFlow+y);
return z;
}
Le calcul de la masse de frigorigène dans les échangeurs diphasiques exige des précautions particulières, car on
ne connaît pas avec précision la répartition des phases liquide et vapeur.
En mode non-nominal, le sous-refroidissement est calculé pour que la masse de réfrigérant du circuit soit
conservée.
Le taux de vide ε est défini par la section occupée par la vapeur par rapport à la section totale de l’échangeur. Sa
connaissance est indispensable pour prédire la charge du système frigorifique. En effet la masse totale dans un
échangeur peut s’exprimer en fonction de la masse volumique moyenne :
ρ m = ερ v + (1 − ε )ρ l (12)
ε, fonction d'une constante Kh et du glissement S des phases liquide et vapeur, est donné par :
KH
ε= (13)
1 − x ρv
1+ S
x ρl
Le calcul de la masse volumique moyenne est effectué en intégrant (13) entre les titres d'entrée et de sortie de
l'échangeur.
La masse contenue dans la ligne liquide est quant à elle déterminée en considérant une longueur de tube de
même section que celle du condenseur, qui est entrée dans l'écran du TechnoDesign de la figure 4. Le code est
donné ci-dessous :
7 Utilisation du pilote
Les résultats sont affichés à l'écran une fois la convergence obtenue. Si les valeurs que vous entrez sont très
différentes de celles de dimensionnement, des erreurs de calcul de Thermoptim peuvent être générées, avec
messages. Si nécessaire, choisissez une valeur de recalcul plus proche de la valeur initiale.
La figure 7 montre les résultats de simulation obtenus lorsque l'on fait varier la température de l'air de
refroidissement, pour le paramétrage des écrans technologiques retenu précédemment. L'influence de la vitesse
de rotation est donnée figure 8.
Dans cet exemple, nous n'avons fait varier que deux variables, mais il serait très simple d'étudier l'influence des
débits d'air et d'eau glycolée, ou de la température de cette dernière, soit en modifiant leurs valeurs dans les
écrans du simulateur avant recalcul avec ce pilote, soit en le modifiant pour que ces valeurs apparaissent dans
l'écran de pilotage et soient ensuite automatiquement mises à jour.
Lorsque le compresseur utilisé n'est plus volumétrique mais centrifuge, les équations (4) à (7) ne sont plus
valables, et doivent être remplacées par une représentation aussi précise de la cartographie du turbocompresseur.
Les caractéristiques du turbocompresseur sont données par les équations (14) et (15) :
Pr ·
Rp = = f(m c) (14)
Pa
·
ηs= f(m c) (15)
Ces équations sont ajustées numériquement à partir des données disponibles (cf. figures 9 et 10), comme
expliqué dans la note ModelisationSimplifieeTurbomachines.doc et dans le tome 4 du manuel de référence de
Thermoptim .
La cartographie du compresseur utilisé a été établie à partir de données trouvées dans la littérature.
Le débit est normé pour que la cartographie soit utilisable pour des compresseurs semblables de dimensions
différentes.
technoCompr.setDataFile(dataFile);
technoCompr.makeDesign();
Avant de lancer les calculs, on lit à l'écran la valeur de la vitesse de rotation choisie, et on met à jour le
TechnoDesign en l'adimensionnant:
N_value=Util.lit_d(Nref_value.getText())/technoCompr.Nref;
technoCompr.setDesignValues();
technoCompr.setN(N_value);
technoCompr.setNparameters();
Pendant les mises à jour qui prennent place dans la fonction fcn(),la vitesse de rotation réduite est actualisée une
fois les nouvelles conditions d'aspiration connues :
Une fois les calculs terminés, on vérifie si la vitesse de rotation réduite reste située dans les limites admissibles
pour la cartographie choisie. Sinon l'utilisateur est averti.
technoCompr.checkMapValidity();
Les résultats du modèle sont tout à fait cohérents avec ceux obtenus avec le compresseur volumétrique pour ce
qui concerne l'influence de la température extérieure, les seules différences étant dues au changement de
caractéristiques (cf. figure 11).
Celle de la vitesse de rotation est quant à elle assez différente de celle obtenue avec le compresseur volumétrique
(cf. figure 12).
Si le fluide entre à l'état diphasique dans l'évaporateur, les équations sont légèrement différentes.