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

**Kevin_Mylano** · 19/06/2016, 12h47

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**VinsS** · 19/06/2016, 16h02

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
class TT(T):
    def __init__(self,a,b,c):
        super().__init__(self,a,b,c)

plutôt que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**VinsS** · 19/06/2016, 16h43

Je vois que ton code est entre balises.

Donc nous avons self.vect qui est une array numpy

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Ce qui veux dire pour la suite de ton code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**Kevin_Mylano** · 20/06/2016, 14h15

Voici un exemple de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**wiztricks** · 20/06/2016, 15h00

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Kevin_Mylano** · 20/06/2016, 15h27

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 Python :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**wiztricks** · 20/06/2016, 15h44

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Kevin_Mylano** · 21/06/2016, 10h53

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

**wiztricks** · 21/06/2016, 11h23

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

**Kevin_Mylano** · 21/06/2016, 14h29

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 PYTHON :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**wiztricks** · 21/06/2016, 14h56

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

         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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

- W

**Kevin_Mylano** · 24/06/2016, 12h05

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 PYTHON :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**wiztricks** · 24/06/2016, 13h39

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Kevin_Mylano** · 28/06/2016, 14h10

Bonjour,

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

Code PYTHON :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**wiztricks** · 28/06/2016, 14h49

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Kevin_Mylano** · 08/07/2016, 14h50

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

Moteur de calcul : héritage, attribut, classe et optimisation de code [Python 2.X]

Calcul scientifique Python

Discussions similaires

Partager

Partager