Moteur de calcul : héritage, attribut, classe et optimisation de code

Bonjour à tous,

actuellement, je travaille sur le déploiement d'un moteur de calcul pour un centre de recherche.

Je me suis vite rendu compte d'une croyance que j'ai eu s'est révélée fausse en codant. Je préfère mettre un exemple ; ça sera plus parlant à mon humble avis.

Soit le code suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

""" petit test """   import numpy as np   class T(object):   def __init__(self,a,b,c): self.a = a self.b = b self.c = c "self.vect = np.ones(3)"   def __calcul__(self): self.a = self.a+1 self.b = self.b+1 self.c = self.c+1 self.vect = np.array([self.a,self.b,self.c]) return self.vect   class TT(T):   def __init__(self,a,b,c): T.__init__(self,a,b,c) # on obtient le 1er self.vect # self.vect3 = []   def __calcul__(self): T.__calcul__(self) # 1er calcul # print T.__calcul__(self) self.d = 2*self.a # e doit valoir 4 #♦ self.e = 2*self.b # // # self.f = 2*self.c # // # self.vect2 = np.array([self.d,self.e,self.f]) #return self.vect2 for i in range(len(self.vect)): self.vect = self.vect2 print self.vect self.vect2 = 2*self.vect print self.vect2 self.vect = self.vect2 print self.vect T.__calcul__(self) print T.__calcul__(self)

---

Mon problème c'est que je désire qu'à chaque itération recalculer la valeur de mon vecteur self.vect et réinjecter ladite valeur dans T.__calcul__(self) ce que
je n'obtiens pas évidemment. Je dois faire ce même procéder pour diverses méthodes jusqu'à atteindre un certain seuil et optimiser le temps de calcul.
Pour le moment, je suis 'bloqué'. Je pensais à tort que par le mot clé self, 'l'injection' se faisait automatiquement en appelant de nouveau la méthode T.__calcul__(self).

Merci à vous tous par avance de votre aide.

Cordialement,

KM

Salut,

Il faut mettre ton code entre des balises [CODE] parce que sans les indentations le code n'est pas compréhensible.

Je peux déjà te dire que créer une méthode "dunded" comme __calcul__ est à proscrire, cette syntaxe est réservée au langage, donc utilise plutôt _calcul ou calcul_ si tu te sens une raison de marquer cette méthode.

Utilise

Code:

---

1 2 3 4

class TT(T): def __init__(self,a,b,c): super().__init__(self,a,b,c)

---

plutôt que

Code:

---

1 2 3 4

class TT(T): def __init__(self,a,b,c): T.__init__(self,a,b,c)

---

et, dernière chose, lorsque tu fais

Code:

---

1 2	print T.__calcul__(self)

---

tu passes deux arguments à la méthode, sa propre instance de classe, qui est implicite, et l'instance de la classe TT. Supprime le self et ça ira mieux.

Je vois que ton code est entre balises.

Donc nous avons self.vect qui est une array numpy

Code:

---

1 2	self.vect = np.array([self.a,self.b,self.c])

---

Ce qui veux dire pour la suite de ton code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

self.vect2 = np.array([self.d,self.e,self.f])   for i in range(len(self.vect)): self.vect = self.vect2 # maintenant self.vect = np.array([self.d,self.e,self.f]) print self.vect self.vect2 = 2*self.vect # self.vect2 = 2 * np.array([self.d,self.e,self.f]) print self.vect2 self.vect = self.vect2 # maintenant self.vect = 2 * np.array([self.d,self.e,self.f]) print self.vect T.__calcul__() # self.vect redeviendra np.array([self.a,self.b,self.c]) et on refait un tour print T.__calcul__()

---

J'espère que tu te comprends, parce que moi pas.

Voici un exemple de code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

import numpy as np   class A(object):   def __init__(self,a,b,c):   self.a = a   self.b = b   self.c = c   self.v = np.ones(3)   def calcul(self):   self.d = self.a + self.b + self.c   self.e = self.a * self.b * self.c   self.f = self.a - self.b - self.c   self.v = np.array([self.d,self.e,self.f])   return self.v   class B(A):   def __init__(self,a,b,c):   A.__init__(self,a,b,c)   def calcul(self):   #A.calcul(self)   for i in range(10):   A.calcul(self)   self.v2 =2*A.calcul(self)   A.v = self.v2   self.v2 = 2*A.v   print A.v   #return self.v2

---

au lieu d'obtenir successivement les vecteurs :

[6 2 -2], [12 4 -4],[24 8 -8]...j'obtiens uniquement [6 2 -2] : ça peut sembler tout bête mais je bloque.

Merci à vous

YZ.

Salut,
Relisez votre code, il se résume à écrire:

Code:

---

1 2 3 4 5

>>> v = 1 >>> for _ in range(5): ... v2 = 2 * v ... print(v) ...

---

Si vous voulez avoir 1, 2, 4, ... il faut mettre à jour v:

Code:

---

1 2 3 4 5 6

>>> v = 1 >>> for _ in range(5): ... v2 = 2*v ... v = v2 ... print(v) ...

---

à chaque itération.
Bien sûr, embrouillez le tout avec héritage, surcharge, copie dans des variables de classes, array numpy,... l'essentiel devient noyé dans un épais brouillard mais votre code ne fait guère plus..
Essayez de raconter en français ce que vous voulez faire exactement plutôt que de montrer comment vous avez essayé de traduire je ne sais quoi en Python.

- W

Merci de votre retour. Mais je suis toujours 'chagriné' et en plus il pleut lol :


Je comprends le principe. Le fait est lorsque je rappelle des méthodes de calculs pour la correction de mon champ de température, je ne suis pas certain cas chaque itération c'est bien un

nouveau vecteur d'état qui est recalculé et réinjecter des mes méthodes :

Voici le code de correction du champ de température :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

from DeperditionCourante import UC from InputDataParameters import ConditLimite from InputDataParametersIntermediate import TempLinear, LameDAir2 from ResistanceThermique import ResisUtileIsolant, ResisLameDair, ResisSupInt, ResisSupExt, ResisEnduit, ResisMurSupport import numpy as np   class Correction(UC): """ Correction des températures """   def __init__(self,humidite,em,lambdam,epsilon1,epsilonm,ei,epsilon2,lambdaid,Ii,fTi,Tiref,fui,uiref,ee,lambdae,epsilone,ea,Tint,Text,E,v,ui,deltaU2,FRi,FTi,Fui,Rid): ConditLimite.__init__(self,Tint,Text) UC.__init__(self,humidite,em,lambdam,epsilon1,epsilonm,ei,epsilon2,lambdaid,Ii,fTi,Tiref,fui,uiref,ee,lambdae,epsilone,ea,Tint,Text,E,v,ui,deltaU2,FRi,FTi,Fui,Rid) TempLinear.__init__(self,em,lambdam,epsilon1,epsilonm,ei,epsilon2,lambdaid,Ii,fTi,Tiref,fui,uiref,ee,lambdae,epsilone,ea,Tint,Text,E,v,ui,deltaU2) LameDAir2.__init__(self,em,lambdam,epsilon1,epsilonm,ei,epsilon2,lambdaid,Ii,fTi,Tiref,fui,uiref,ee,lambdae,epsilone,ea,Tint,Text,E,v,ui,deltaU2)   def calcul(self):   # Première Phase de Calcul #   # Calcul des températures initiales, des résistances thermiques et de UC #   TempLinear.calcul(self) ResisUtileIsolant.calcul(self) ResisLameDair.calcul(self) ResisSupInt.calcul(self) ResisSupExt.calcul(self) ResisEnduit.calcul(self) ResisMurSupport.calcul(self) UC.calcul(self)   self.Q = UC.calcul(self)*(self.Tint-self.Text)   self.Tsec = self.Q*self.Rsext+ self.Text self.Teic = self.Q*self.Re + self.Tsec self.T2c = self.Q*self.Riu + self.Teic self.T1c = self.Q*self.Ra + self.T2c self.Tsic = self.Q*self.Rm + self.T1c self.VectEtat2 = np.array([self.Tsec,self.Teic,self.T2c,self.T1c,self.Tsic])   self.Qc = (self.Tint - self.Text)/ResisSupInt.calcul(self)   # Exemple pour le moment #   self.seuil= 0.1   while (((abs(self.VectEtat2[0]-self.VectEtat[4]))>self.seuil)|((abs(self.VectEtat2[0]-self.VectEtat[2]))>self.seuil)|((abs(self.VectEtat2[2]-self.VectEtat[1]))>self.seuil)|((abs(self.VectEtat2[3]-self.VectEtat[0]))>self.seuil)|((abs(self.VectEtat2[4]-self.VectEtat[3]))>self.seuil)|((abs(self.Qc-self.Q))>self.seuil)):     self.VectEtat = self.VectEtat2   TempLinear.calcul(self) LameDAir2.calcul(self) ResisUtileIsolant.calcul(self) ResisLameDair.calcul(self) ResisSupInt.calcul(self) ResisSupExt.calcul(self) ResisEnduit.calcul(self) ResisMurSupport.calcul(self)   UC.calcul(self)   self.Q = UC.calcul(self)*(self.Tint-self.Text) self.Tsec = self.Q*self.Rsext + self.Text self.Teic = self.Q*self.Re + self.Tsec self.T2c = self.Q*self.Riu + self.Teic self.T1c = self.Q*self.Ra + self.T2c self.Tsic = self.Q*self.Rm + self.T1c self.VectEtat2 = np.array([self.Tsec,self.Teic,self.T2c,self.T1c,self.Tsic]) self.Qc = (self.Tint - self.Text)/ResisSupInt.calcul(self)   return self.VectEtat, self.Riu, self.Ra, self.Rsint, self.Rsext, self.Re, self.Rm, self.Q

---

En gros je dois réussir à boucler ( de façon la plus rapide possible...mais pas pour le moment) jusqu'à atteindre un seuil :

VectEtat -> VectEtatCorriger + conditions limites -> Calculer les résistances -> Calculer Uc -> Calculer le Flux Q et recommencer l'opération ainsi de suite :
VectEtat = VecEtatCorriger -> ...le hic c'est j'ai l'impression que mon Vecteur d'état ne se calcul qu'une fois et que je n'obtiens pas les bons résultats pour mes méthodes...

J'espère avoir été un peu plus clair. Merci à Vous.

KM

Citation:

---

Envoyé par Kevin_Mylano

J'espère avoir été un peu plus clair. Merci à Vous.

---

Vous ajoutez du brouillard au brouillard...

Déjà quand le vois:

Code:

---

1 2 3 4 5 6 7 8

TempLinear.calcul(self) ResisUtileIsolant.calcul(self) ResisLameDair.calcul(self) ResisSupInt.calcul(self) ResisSupExt.calcul(self) ResisEnduit.calcul(self) ResisMurSupport.calcul(self) UC.calcul(self)

---

i.e. des procédures qui modifient je ne sais quoi plutôt que des fonctions... in fine, vous ne savez plus qui fait quoi.
Essayez d'avoir une façon de coder qui vous assure de garder un minimum le contrôle i.e. être sûr que ce que va faire l'interpréteur est bien ce que vous attendiez *et* permettre à d'autre de comprendre ce que fait votre code sans avoir à farfouiller dans 50 fichiers.
note: en général, lorsque mon code devient incompréhensible/ingérable, je le benne et je recommence.


- W

Bonjour à tous,

je pense qu'avec un schéma et expliquer mieux de quelle façon je désire implémenter mon modèle ça sera peut-être plus clair ; du moins je le souhaite. Si je me plaçais du point de vue d'un

automaticien, je dirais dans mon contexte que je dois implémenter une boucle d ' asservissement dans l'idée. Ce qui nous donne :


--------------------- ---------------------------- --------------------- ----------------------
-- Vecteur d'état --------->-- Calcul des Résistances ---------> -- Calcul de UC ---------> -- Calcul du Flux Q
--------------------- ---------------------------- --------------------- ----------------------
/\ ||
|| ||
|| ||
|| ----------------------------------------------------------------------------||
------------------------------- Corriger les Variables d'états : Arrêt si |Ti+1-Ti|<seuil -------------||
--------------------------------------------------------------------------- ||

Ma première idée a donc été de créer pour chacun des blocs une classe correspondante par héritage successif . Le point névralgique c'est qu'une fois le premier calcul de correction effectué comment l'enregistré de nouveau et relancé toute la chaîne de calcul jusqu'à atteindre le seuil d'arrêt et obtenir les valeurs finales de mon vecteur d'état de température, de mes résistances,
de UC, du flux Q....un peu comme un serpent qui se mordrait la queue...

Merci encore à tous de vos conseils de conception.

PS : j'aurais du peut-être préciser que je suis en stage de formation

Cordialement,

KM

Citation:

---

Envoyé par Kevin_Mylano

Ma première idée a donc été de créer pour chacun des blocs une classe correspondante par héritage successif . Le point névralgique c'est qu'une fois le premier calcul de correction effectué comment l'enregistré de nouveau et relancé toute la chaîne de calcul jusqu'à atteindre le seuil d'arrêt et obtenir les valeurs finales de mon vecteur d'état de température, de mes résistances, de UC, du flux Q....un peu comme un serpent qui se mordrait la queue...

---

Les flèches rendent compte d'une séquence dans les traitements/calculs mais ce qui serait aussi important sont les données en entrée et les données en sortie (voire les données communes à chaque...). Mais cela n'est que "conception", ce que vous avez écrit sur le papier avant de coder.
Pour ce qui est de la réalisation, essayez de virer vos "class" (au moins imaginez sans) vous avez une liste de fonctions f, g, h, ... à appliquer à... qui retournent... ou qui modifient des variables "mutables".

Vous avez aussi un "manager"/"contrôleur"/"dispatcher" au dessus qui va organiser l'appel de la séquence de fonctions avec les objets/paramètres attendus et récupération des retours. C'est lui qui organise le flux d'opérations/informations de votre dessin - et donc vous avez tout intérêt à coller à votre diagramme i.e. suivre votre plan et pouvoir vous assurer facilement que c'est ce plan là qui est suivi.

- W

Re-bonjour,

j'ai tenté de suivre vos conseils. Mais je n'obtiens aucun résultat en retour( sauf le vecteur initiale pour mon vecteur d'état )

Pour l'ensemble, j'ai crée une classe simulation qui me permet de rentrer mes paramètres d'entrées ; par la suite successivement, les fonctions de calculs qui prennent à priori le résultat

précédemment calculé et ce jusqu'à la méthode finale de correction des températures qui récupère toutes les autres :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118

import numpy as np from scipy import exp   class Simulation(object): """ Simulation du calcul de correction des température """   def __init__(self,h,em,lambdam,eps1,epsm,ei,eps2,lambdai,Ii,fti,tiref,fui,uiref,ee,lambdae,epsl,ea,Tint,Text,E,v,ui,delta): self.input = np.array([h,em,lambdam,eps1,epsm,ei,eps2,lambdai,Ii,fti,tiref,fui,uiref,ee,lambdae,epsl,ea,Tint,Text,E,v,ui,delta]) self.Tsint = self.input[17] self.Tsext = self.input[18] self.VectEtat2 = np.ones(5) self.VectEtat = np.ones(5) self.interdata = np.ones(5) self.vectR = np.ones(6) self.Qc = 0.0 self.Q = 0.0   # Preùière Phase de Calcul #   def CalculTemp(self,*arg):   self.T1 = self.Tsint - ((self.Tsint - self.Tsext)/(self.input[1]+ self.input[5] + self.input[13]+ self.input[16]))*self.input[1] self.T2 = self.T1 - ((self.Tsint - self.Tsext)/(self.input[1] + self.input[5] + self.input[13] + self.input[16]))*self.input[16] self.Tei = self.Tsext + ((self.Tsint - self.Tsext)/(self.input[1] + self.input[5] + self.input[13] + self.input[16]))*self.input[13] self.VectEtat = np.array([self.T1,self.T2,self.Tei,self.Tsint,self.Tsext]) return self.VectEtat   def CalculCoefficient(self,*arg):   self.hasint = 2.5 self.deltaTa = abs(self.VectEtat[0] - self.VectEtat[1]) if (self.deltaTa <= 5.): self.haa = max([1.25,(0.025/self.input[16])]) elif(self.deltaTa > 5.): self.haa = max(0.73*self.deltaTa**1/3,0.025/self.input[16]) self.hra = (1.0/((1.0/self.input[3])+(1./self.input[6])-1.)) self.hrsint = self.input[16]*4*5.67*pow(10,-8)*((self.VectEtat[3] + self.input[17])/2. + 273.15)**3.0 if self.input[19] == 1: self.hasext = 2.5 elif self.input[19] == 2: self.hasext = 4 + 4*self.input[20] self.hrsext = self.input[13]*4*5.67*pow(10,-8)*((self.VectEtat[4] + self.input[18])/2. + 273.15)**3 self.interdata = np.array([self.haa,self.hra,self.hasext, self.hrsext,self.hasint,self.hrsint]) return self.interdata   def CalculRes(self,*arg):   if self.input[8]==1: self.FRi=1 elif self.input[8]==0: self.FRi = 1.15   self.FTi=exp(self.input[9]*(((self.VectEtat[1]+self.VectEtat[2])/2.0)-self.input[10]))   if self.input[0]==0:   self.Fui=1 else:   self.Fui = exp(self.input[9]*(self.input[21]-self.input[12]))     self.Rid = self.input[5]/self.input[2]   self.Riu = self.Rid/(self.FRi*self.FTi*self.Fui)   self.Ra = 1.0/(self.interdata[0] +self.interdata[1])   self.Rsint = 1.0/(self.interdata[4] + self.interdata[5])   self.Rsext = 1.0/(self.interdata[2] + self.interdata[3])   self.Re = self.input[13] / self.input[14]   self.Rm = self.input[1] / self.input[2]   self.vectR = np.array([self.Rid, self.Riu, self.Ra, self.Rsint,self.Rsext,self.Re,self.Rm])   return self.vectR   def CalculDep(self,*arg): self.uc = 1.0/(self.vectR[0]+self.vectR[1]+self.vectR[2]+self.vectR[3]+self.vectR[4]+self.vectR[5]+self.vectR[6]) return self.uc   def CorrectTemp(self,*arg):   self.Q = self.uc*(self.Tint-self.Text) self.Tsec = self.Q*self.Rsext+ self.Text self.Teic = self.Q*self.Re + self.Tsec self.T2c = self.Q*self.Riu + self.Teic self.T1c = self.Q*self.Ra + self.T2c self.Tsic = self.Q*self.Rm + self.T1c   self.VectEtat2 = np.array([self.T1c,self.T2c,self.Teic,self.Tsic,self.Tsec])   return self.VectEtat2   def CorrectionFlux(self,*arg):   self.Qc = (self.input[17]-self.VectEtat2[4])/self.vectR[3] return self.Qc   def CorrectionTemp(self):   seuil = 0.00001   while((abs(self.Qc-self.Q))>seuil): self.VectEtat = self.VectEtat2 Simulation.CalculTemp(self.VectEtat) Simulation.CalculCoefficient(self.VectEtat) Simulation.CalculRes(self.interdata) Simulation.CalculDep(self.vectR) Simulation.CorrectTemp(self.VectEtat2) Simulation.CorrectionFlux(self.Q)   return self.VectEtat

---

Merci de votre aide

Cordialement,

KM

Salut,

Je prends la première fonction/méthode:

Code:

---

1 2 3 4 5 6 7

def CalculTemp(self,*arg):   self.T1 = self.Tsint - ((self.Tsint - self.Tsext)/(self.input[1]+ self.input[5] + self.input[13]+ self.input[16]))*self.input[1] self.T2 = self.T1 - ((self.Tsint - self.Tsext)/(self.input[1] + self.input[5] + self.input[13] + self.input[16]))*self.input[16] self.Tei = self.Tsext + ((self.Tsint - self.Tsext)/(self.input[1] + self.input[5] + self.input[13] + self.input[16]))*self.input[13] self.VectEtat = np.array([self.T1,self.T2,self.Tei,self.Tsint,self.Tsext]) return self.VectEtat

---

que vous l'appelez plus bas:

Code:

---

Simulation.CalculTemp(self.VectEtat)

---

Déjà vous foutez la grouille avec Simulation.CalculTemp qui appelle une fonction prenant en premier paramètre l'instance i.e. "self" et pas autre chose qu'il serait plus simple d'écrire: self.CalculTemp(). Ensuite, vous avez une liste de paramètre en entrée (*args) dont vous ne faites rien. Et vous modifiez l'attribut self.VectEtat que vous retournez à l'appelant qui n'en fait rien. Quelle que soit votre intention en écrivant ce code, c'est illisible.

Faites des fonctions simples:

Code:

---

1 2 3

def CalculTemp(Tsint, Tsext, input_): ... return VectEtat

---

- W

Bonjour à tous,

j'ai modifié mon code de nouveau. Pourtant en essayant les conseils que l'on m'a donné jusqu'à présent je n'ai toujours pas la sensation que ma boucle de rétro-action(feedback) fonctionne

correctement : en gros que le vecteur d'état de mes températures n'est pas recorrigé à chaque itération et d'autre part que même si le vecteur d'état était corrigé, lorsque j'appelle mes fonctions

de calculs comment être bien sur que c'est les bonnes et nouvelles valeurs recalculées réinjectées dans mes méthodes. En C, je serais passé par un pointeur mais tout est référence en Python,

donc cela devrait se faire automatiquement....

Je vous joins le code

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196

class Simulation(object):   def __init__(self,humidite,em,lambdam,eps1,epsm,ei,eps2,lambdai,Ii,fti,tiref,fui,uiref,ee,lambdae,epsl,ea,Tint,Text,E,v,ui,delta2):   self.seuil = 0.001 self.humidite = humidite self.em = em self.lambdam = lambdam self.eps1 = eps1 self.epsm = epsm self.ei = ei self.eps2 = eps2 self.lambdai = lambdai self.Ii = Ii self.fti = fti self.tiref = tiref self.fui = fui self.uiref = uiref self.ee = ee self.lambdae = lambdae self.epsl = epsl self.ea = ea self.Tint = Tint self.Text = Text self.E = E self.v = v self.ui = ui self.delta2 = delta2   self.deltaTa = 0.0 self.haa = 0.0 self.hra = 0.0 self.hasext = 0.0 self.hrsext = 0.0 self.hasint = 0.0 self.hrsint = 0.0   self.FRi = 0.0 self.FTi = 0.0 self.Fui = 0.0 self.Rid = 0.0   self.T1c = 0.0 self.T2c = 0.0 self.Teic = 0.0 self.Tsic = 0.0 self.Tsec = 0.0   self.Tsint = self.Tint self.Tsext = self.Text self.T1 = 0.0 self.T2 = 0.0 self.Tei = 0.0   self.Riu = 0.0 self.Ra = 0.0 self.Rsint = 0.0 self.Rsext = 0.0 self.Re = 0.0 self.Rm = 0.0   self.Q = 0.0 self.uc = 0.0     #self.VectEtat2 = np.ones(5) #self.VectEtat = np.ones(5) #self.coef_echange = np.ones(5) #self.vectR = np.ones(7)   self.VectEtat = np.array([self.T1,self.T2,self.Tei,self.Tsint,self.Tsext]) self.coef_echange = np.array([self.haa,self.hra,self.hasext, self.hrsext,self.hasint,self.hrsint]) self.vectR = np.array([self.Rid, self.Riu, self.Ra, self.Rsint,self.Rsext,self.Re,self.Rm]) self.VectEtat2 = np.array([self.T1c,self.T2c,self.Teic,self.Tsic,self.Tsec])     def Temp_vect(self): """Pour faire le lien dans le code entre le vecteur d'état         et nos variables d'instances         """ self.T1 = self.VectEtat[0] self.T2 = self.VectEtat[1] self.Tei = self.VectEtat[2] self.Tsint = self.VectEtat[3] self.Tsext = self.VectEtat[4]   return self.T1, self.T2, self.Tei, self.Tsint, self.Tsext     def InitTemp(self):   """Premier calcul pour l initialisation des temperatures""" self.T1 = self.Tsint - ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.em self.T2 = self.T1 - ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.ea self.Tei = self.Tsext + ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.ee self.VectEtat = np.array([self.T1,self.T2,self.Tei,self.Tsint,self.Tsext])   return self.VectEtat   def CalculCoefficient(self):   """Calcul des coefficients de convection"""   self.hasint = 2.5 self.deltaTa = abs(self.T1 - self.T2) if (self.deltaTa <= 5): self.haa = max([1.25,(0.025/self.ea)]) elif(self.deltaTa > 5): self.haa = max(0.73*self.deltaTa**1/3,0.025/self.ea) self.hra = (1.0/((1.0/self.eps1)+(1./self.eps2)-1.))*4*5.67*pow(10,-8)*((self.T1 + self.T2)/2.0 + 273.15)**3 self.hrsint = self.ea*4*5.67*pow(10,-8)*((self.Tsint + self.Tint)/2. + 273.15)**3.0 if self.E == 1: self.hasext = 2.5 elif self.E == 2: self.hasext = 4 + 4*self.v self.hrsext = self.ee*4*5.67*pow(10,-8)*((self.Tsext + self.Text)/2. + 273.15)**3 self.coef_echange = np.array([self.haa,self.hra,self.hasext, self.hrsext,self.hasint,self.hrsint])   return self.coef_echange   def CalculRes(self): """Calcu des resistances thermiques"""   if self.Ii==1: self.FRi = 1 elif self.Ii==0: self.FRi = 1.15   self.FTi = exp(self.fti*(((self.T2 + self.Tei)/2.0)-self.tiref))   if self.humidite==0:   self.Fui = 1 else:   self.Fui = exp(self.fti*(self.ui-self.uiref))     self.Rid = self.ei/self.lambdai   self.Riu = self.Rid/(self.FRi*self.FTi*self.Fui)   self.Ra = 1.0/(self.haa + self.hra)   self.Rsint = 1.0/(self.hasint + self.hrsint)   self.Rsext = 1.0/(self.hasext + self.hrsext)   self.Re = self.ee / self.lambdae   self.Rm = self.em / self.lambdam   self.vectR = np.array([self.Rid, self.Riu, self.Ra, self.Rsint,self.Rsext,self.Re,self.Rm])   return self.vectR   def CalculUc(self): """Calcul de la deperdition courrante"""   self.uc = 1.0/(self.Rid +self.Riu + self.Ra +self.Rsint + self.Rsext + self.Re + self.Rm) return self.uc     def CorrectTemp(self): """Calcul de correction de temperatures"""   self.Q = self.uc*(self.Tint-self.Text) self.Tsec = self.Q*self.Rsext + self.Text self.Teic = self.Q*self.Re + self.Tsec self.T2c = self.Q*self.Riu + self.Teic self.T1c = self.Q*self.Ra + self.T2c self.Tsic = self.Q*self.Rm + self.T1c   self.VectEtat2 = np.array([self.T1c,self.T2c,self.Teic,self.Tsic,self.Tsec])   return self.VectEtat2     def CalculTemp(self): """Correction des temperatures"""   self.InitTemp() res= 100.   while res>self.seuil: self.Temp_vect() self.CorrectTemp() self.CalculCoefficient() self.CalculRes() self.CalculUc() res = np.linalg.norm(self.VectEtat-self.VectEtat2) print res   return self.VectEtat,self.uc

---

Mon dernier 'souci' vient principalement de ma dernière méthode : au début j'ai mon VectEtat, je lance le 1er calcul de correction : VectEtat -> VectEtat2
Ensuite, je dois reccoriger VectEtat en passant par la méthode CorrectTemp() qui doit me donner un nouveau vecteur de temperature VectEtat3 et recalculer toutes les méthodes avec ce nouveau vecteur, recalculer la différence : VectEtat3 - VectEtat2 as soon as...VecEtati+1 - VecEtati => CorrerTemp(self.VecEtat[i]) , CalculCoefficient(self.VecEtat[i]), CalculRes(self.VecEtat[i]),
CalculUc(self.VecEtat[i])

J'espère avoir été à peu près clair. Merci de votre aide.

Cordialement,

KM

Citation:

---

Envoyé par Kevin_Mylano

correctement : en gros que le vecteur d'état de mes températures n'est pas recorrigé à chaque itération et d'autre part que même si le vecteur d'état était corrigé, lorsque j'appelle mes fonctions de calculs comment être bien sur que c'est les bonnes et nouvelles valeurs recalculées réinjectées dans mes méthodes. En C, je serais passé par un pointeur mais tout est référence en Python

---

Ben si vous écrivez:

Code:

---

1 2 3 4 5 6 7 8

while res>self.seuil: self.Temp_vect() self.CorrectTemp() self.CalculCoefficient() self.CalculRes() self.CalculUc() res = np.linalg.norm(self.VectEtat-self.VectEtat2) print res

---

Il est clair que vous ne voyez ni de quoi vous partez, ni ce que vous ré-utilisez: vos fonctions ne prennent aucun paramètre et vous jetez à la benne ce qu'elles retournent. Je ne peux que vous redire ce que je vous ai écrit la fois précédente: faites de vraies fonctions et contrôlez ce qui doit évoluer dans la boucle while plutôt que de tout masquer dans des méthodes.

- W

Bonjour,

j'ai essayé de raisonner d'une autre façon pourtant je ne suis toujours pas satisfait.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172

import numpy as np from scipy import exp   class Essai(object):   def __init__(self,humidite,em,lambdam,eps1,epsm,ei,eps2,lambdai,Ii,fti,tiref,fui,uiref,ee,lambdae,epse,ea,Tint,Text,E,v,ui,delta2):   self.seuil = 0.001 self.humidite = humidite self.em = em self.lambdam = lambdam self.eps1 = eps1 self.epsm = epsm self.ei = ei self.eps2 = eps2 self.lambdai = lambdai self.Ii = Ii self.fti = fti self.tiref = tiref self.fui = fui self.uiref = uiref self.ee = ee self.lambdae = lambdae self.epse = epse self.ea = ea self.Tint = Tint self.Text = Text self.E = E self.v = v self.ui = ui self.delta2 = delta2   self.deltaTa = 0.0 self.haa = 0.0 self.hra = 0.0 self.hasext = 0.0 self.hrsext = 0.0 self.hasint = 0.0 self.hrsint = 0.0   self.FRi = 0.0 self.FTi = 0.0 self.Fui = 0.0 self.Rid = 0.0   self.T1c = 0.0 self.T2c = 0.0 self.Teic = 0.0 self.Tsic = 0.0 self.Tsec = 0.0   self.Tsint = self.Tint self.Tsext = self.Text self.T1 = 0.0 self.T2 = 0.0 self.Tei = 0.0   self.Riu = 0.0 self.Ra = 0.0 self.Rsint = 0.0 self.Rsext = 0.0 self.Re = 0.0 self.Rm = 0.0   self.Q = 0.0 self.uc = 0.0     def InitTemp(self,VectEtat):   self.T1 = self.Tsint - ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.em self.T2 = self.T1 - ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.ea self.Tei = self.Tsext + ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.ee VectEtat = np.array([self.T1,self.T2,self.Tei,self.Tsint,self.Tsext])   return VectEtat # Vect' = Init(Vect) #   def CalculCoefficient(self,VectEtat):   self.hasint = 2.5 self.deltaTa = abs(self.T1 - self.T2) if (self.deltaTa <= 5): self.haa = max([1.25,(0.025/self.ea)]) elif(self.deltaTa > 5): self.haa = max(0.73*self.deltaTa**1/3,0.025/self.ea) self.hra = (1.0/((1.0/self.eps1)+(1./self.eps2)-1.))*4*5.67*pow(10,-8)*((self.T1 + self.T2)/2.0 + 273.15)**3.0 self.hrsint = self.epsm*4*5.67*pow(10,-8)*((self.Tsint + self.Tint)/2. + 273.15)**3.0 if self.E == 1: self.hasext = 2.5 elif self.E == 2: self.hasext = 4 + 4*self.v self.hrsext = self.epse*4*5.67*pow(10,-8)*((self.Tsext + self.Text)/2. + 273.15)**3.0 coef_echange = np.array([self.haa,self.hra,self.hasext, self.hrsext,self.hasint,self.hrsint])   return coef_echange # coef_echange = CalculCoef(Vect')= Calcul(Init(vect)) ---- self.haa,self.hra,self.hasext, self.hrsext,self.hasint,self.hrsint   def CalculRes(self,coef_echange,VectEtat):   if self.Ii==1: self.FRi = 1 elif self.Ii==0: self.FRi = 1.15   self.FTi = exp(self.fti*(((self.T2 + self.Tei)/2.0)-self.tiref))   if self.humidite==0:   self.Fui = 1 else:   self.Fui = exp(self.fti*(self.ui-self.uiref))     self.Rid = self.ei/2. #self.lambdai   self.Riu = self.Rid/(self.FRi*self.FTi*self.Fui)   self.Ra = 1.0/(self.haa + self.hra)   self.Rsint = 1.0/(self.hasint + self.hrsint)   self.Rsext = 1.0/(self.hasext + self.hrsext)   self.Re = self.ee / self.lambdae   self.Rm = self.em / self.lambdam   vectR = np.array([self.Rid, self.Riu, self.Ra, self.Rsint,self.Rsext,self.Re,self.Rm])   return vectR # vectR = CalculR(coef_e,VectEtatp) = calculcoef(calculcoef(Init(Vect)),Init(Vect)) self.Rid, self.Riu, self.Ra, self.Rsint,self.Rsext,self.Re,self.Rm"""   def CalculUc(self,vectR):   uc = 1.0/(self.Rid +self.Riu + self.Ra +self.Rsint + self.Rsext + self.Re + self.Rm) return uc # uc = CalculUc(vectR) = CalculUc(CalculRes(coef_echange,vect')) = CalculUc(CalculRes(CalculCoefficient(Init(Vect))),Init(Vect))   def CorrectTemp(self,uc,vectR): """Correction des temperatures"""   Q = uc*(self.Tint-self.Text) self.Tsec = Q*self.Rsext + self.Text self.Teic = Q*self.Re + self.Tsec self.T2c = Q*self.Riu + self.Teic self.T1c = Q*self.Ra + self.T2c self.Tsic = Q*self.Rm + self.T1c   VectEtat2 = np.array([self.T1c,self.T2c,self.Teic,self.Tsic,self.Tsec])   return VectEtat2   def CalculTemp(self,V): """Calcul de correction de temperatures"""   V2 = self.InitTemp(V) print V2 res= 100.   while res>self.seuil:   co = self.CalculCoefficient(V2) car = self.CalculRes(co,V2) uc = self.CalculUc(car) V3 = self.CorrectTemp(uc,car) V = V3 V2 = self.InitTemp(V)   res = np.linalg.norm(V-V2) print res   return V

---

Ce qui me 'châgrine' c'est que la valeur de mon vecteur V,V2 et du résidu res ne 'bouge' pas ; alors qu'à priori à chaque itération ça devrait...je perd un pied là

Merci

KM

Salut,

C'est mieux: on appelle des fonctionsméthodes avec des paramètres et on en récupère le retour.
Maintenant, relisez par exemple:

Code:

---

1 2 3 4 5 6 7 8

def InitTemp(self,VectEtat):   self.T1 = self.Tsint - ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.em self.T2 = self.T1 - ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.ea self.Tei = self.Tsext + ((self.Tsint - self.Tsext)/(self.em + self.ei + self.ee + self.ea))*self.ee VectEtat = np.array([self.T1,self.T2,self.Tei,self.Tsint,self.Tsext])   return VectEtat # Vect' = Init(Vect)

---

Si les variables à partir desquelles sont calculés selfT1, T2, T3... ne sont pas mises à jour de temps en temps (ou à chaque itération) VecEtat sera toujours pareil. VectEtat est passé en paramètre mais vous en faites quoi dans vos fonctions? Et si vous n'en faites rien, il pourra changer tant qu'il veut... vous n'en tenez pas compte.

Ce qui rentre, ce que çà calcule et ce que çà sort n'est toujours pas clair...

Je vous suggère (encore une fois) d'écrire de vraies fonctions (çà veut dire entre autre "virer la class") avec des paramètres explicites en rendant plus visible dans le "while" les variables qui sont passées/mises à jour d'une étape à l'autre.

- W

Bonjour,

apparemment, je n'ai pas eu besoin de coder une boucle de rétro-action pour mes calculs. Lorsque je lance le calcul, j'ai bien une variation de mon résidu et de mes températures.

Merci encore

KM