Discussion :

[Kevin_Mylano]

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]

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]

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]

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]

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]

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