problème avec l'incrémentation

Version imprimable

Bonjour,
j'ai créé un script qui calcule certaines paramètres. et afin de minimiser sa taille j'ai utilisé l'incrémentation i pour balayer tous les cas.
le script est le suivant:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 nb_loadcase = 9 i = 1 while i <= nb_loadcase: print 'HCF',i %d # determine the stress value of the second step in the "SKIN" element set stressField = odb.steps['Load'].frames[i+1].fieldOutputs['S'] stressField1 = odb.steps['Load'].frames[i+2].fieldOutputs['S'] topCenter = odb.rootAssembly.instances['V20110406-1-1'].elementSets['SKIN'] Stress = stressField.getSubset(region=topCenter, position=CENTROID).values Stress1 = stressField1.getSubset(region=topCenter, position=CENTROID).values calcul(T_cycle[i-1], f1)
mon blocage est au niveau de la 4ème ligne où je veux afficher HCF1 pour i=1 etc...
de même pour la dernière ligne je veux que le paramètre f1 de la fonction calcul change quand i change. c'est à dire pour i=1 on a f1 et pour i=3 on a f3

merci d'avance

19/07/2011, 17h12
mont29
Deux choses*:

D’une part, pour boucler un certain nombre de fois (connu), en python on utilise for et range(), comme ceci*:
Code:

1 2 for i in range(1, 10): …
Pour itérer avec un i allant de 1 (inclu) à 10 (exclu) (dans ton code, tu n’incrémentais pas du tout i*!).

Ensuite, pour ton problème, tu dois utiliser le formatage des strings –*lis la doc python pour les détails, mais en gros, tu fais*:
Code:

1 2 3 "HFC%i" % 1 # pour un entier, %s pour une string, %d pour un flottant, etc. #Et si tu as plusieurs paramètres à insérer dans la string, il faut utiliser un tuple: "HFC%i, f%i" % (i, i)

Bonjour,

j'ai modifié mon script comme vous m'avez indiqué mais il génère des erreurs.
le script est le 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
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
 
# define the list of target cycle of HCF
T_cycle = [28555200,28555200,19036800,590140800,28555200,38073600,76147200,95184000,47592000]
 
# calculate the static, dynamic and equivalent stresses
def calcul(T_cycle[k-1], f,k):
    maxStress=0
    for idx, value in enumerate(Stress) :
        S11 = value.data[0]
        S22 = value.data[1]
        S12 = value.data[3]
        e = Stress1[idx]
        S_11 = e.data[0]
        S_22 = e.data[1]
        S_12 = e.data[3]
        # calculate the dynamic stress tensor and its eigenvalues
        D11 = (S11-S_11)/2
        D22 = (S22-S_22)/2
        D12 = (S12-S_12)/2
        Dyn1 = ((D11+D22)-sqrt(D11**2+D22**2+4*D12**2-2*D11*D22))/2
        Dyn2 = ((D11+D22)+sqrt(D11**2+D22**2+4*D12**2-2*D11*D22))/2
        # calculate the static stress tensor and its eigenvalues
        St11 = (S11+S_11)/2
        St22 = (S22+S_22)/2
        St12 = (S12+S_12)/2
        Stat1 = ((St11+St22)+sqrt(St11**2+St22**2+4*St12**2-2*St11*St22))/2
        Stat2 = ((St11+St22)-sqrt(St11**2+St22**2+4*St12**2-2*St11*St22))/2
        # calculate the dynamic stress and the static stress
        if abs(Dyn1)>=abs(Dyn2):
            sig_dyn = Dyn1
        else:
            sig_dyn = Dyn2
 
        if abs(Stat1)>=abs(Stat2):
            signe = Stat1/abs(Stat1)
            sig_stat = signe*sqrt(Stat1**2-Stat1*Stat2+Stat2**2)
        else:
            signe = Stat2/abs(Stat2)
            sig_stat = signe*sqrt(Stat2**2-Stat1*Stat2+Stat1**2)
        Max = sig_dyn+sig_stat
        Min = sig_stat-sig_dyn
        R = Min/Max
        alpha_G = abs(sig_D_mean/((sig_dyn/sig_stat)+(sig_D_mean/Rm)))*((1+(sig_dyn/sig_stat)**2)/(sig_dyn**2+sig_stat**2))**0.5
        alpha_S = abs(sig_D_mean/((sig_dyn/sig_stat)+(sig_D_mean/Re)))*((1+(sig_dyn/sig_stat)**2)/(sig_dyn**2+sig_stat**2))**0.5
        if choix == 'Goodman':
            sig_eq = sig_Goodman(Rm, sig_dyn, sig_stat, alpha_G)
        elif choix == 'Gerber':
            sig_eq = sig_Gerber(Re, sig_dyn, sig_stat)
        elif choix == 'Soderberg':
            sig_eq = sig_Soderberg(Re, sig_dyn, sig_stat, alpha_S)
        else:
            print ('Votre choix n appartient pas a la liste precedante')
        if sig_eq > maxStress:
            maxStress = sig_eq
        if sig_eq > y[0]:
            N_cycle = 0
        elif sig_eq <= y[-1]:
            N_cycle = 1.0E+10
        else:
            i=0
            len_y=len(y)
            while (i < len_y - 1):
                if (sig_eq < y[i]) and (sig_eq > y[i+1]):
                    N_cycle = x[i+1]-((y[i+1]-sig_eq)*(x[i+1]-x[i])/(y[i+1]-y[i]))
                    break
                i=i+1
        Damage = T_cycle[k-1]/N_cycle
        if (R<-1) or (R>1):
            propa_DTA1=-1.0E-01
            propa_DTA2=-1.0E-01
            propa_FTA=-1.0E-01
        else:
            j =0
            len_DTA1 = len(DTA1)
            while (j < len_DTA1 - 1):
                if (R > Ratio[j]) and (R < Ratio[j+1]):
                    sig_DTA1 = DTA1[j+1]-((Ratio[j+1]-R)*(DTA1[j+1]-DTA1[j])/(Ratio[j+1]-Ratio[j]))
                    propa_DTA1 = sig_dyn-sig_DTA1
                    sig_DTA2 = DTA2[j+1]-((Ratio[j+1]-R)*(DTA2[j+1]-DTA2[j])/(Ratio[j+1]-Ratio[j]))
                    propa_DTA2 = sig_dyn-sig_DTA2
                    sig_FTA = FTA[j+1]-((Ratio[j+1]-R)*(FTA[j+1]-FTA[j])/(Ratio[j+1]-Ratio[j]))
                    propa_FTA = sig_dyn-sig_FTA
                    break
                j=j+1
 
        f.write('Instance:\t %s\tElement:\t %6d\tSig_stat:\t %E\tSig_dyn:\t %E\tMax:\t %E\tMin:\t %E\tR:\t %E\tSig_eq:\t %E\tN_cycle:\t %E\tMaxStress:\t %E\tDamage:\t %E\tpropa_DTA1:\t %E\tpropa_DTA2:\t %E\tpropa_FTA:\t %E\n'%(value.instance.name,value.elementLabel,sig_stat,sig_dyn,Max,Min,R,sig_eq,N_cycle,maxStress,Damage,propa_DTA1,propa_DTA2,propa_FTA))
 
 
#------------------------------------------------Analyse_frequentielle: HCF-------------------------------------------------------
 
nb_loadcase = 9
i = 1
while i <= nb_loadcase:
    print "HCF%i" %i
    # determine the stress value of the second step in the "SKIN" element set 
    stressField = odb.steps['Load'].frames[i+1].fieldOutputs['S']
    stressField1 = odb.steps['Load'].frames[i+2].fieldOutputs['S']
    topCenter = odb.rootAssembly.instances['V20110406-1-1'].elementSets['SKIN']
    Stress = stressField.getSubset(region=topCenter, position=CENTROID).values
    Stress1 = stressField1.getSubset(region=topCenter, position=CENTROID).values
    calcul(T_cycle[i-1], "f%i" %i,i)
    i=i+1

il se peut que j'ai pas compris exactement votre idée.
pour la ligne 67, j'ai un doute que l'instruction de l'appel du paramètre T_cycle est juste. de même pour les paramètres d'entrée de la fonction calcul et son appel dans la ligne 101.
bon je suis débutante en Python, c'est pourquoi je me bloque toujours même pour des instructions simples.

merci d'avance

20/07/2011, 11h10
brachior
Code:

1 2 def calcul(T_cycle[k-1], f,k):
C'est pas possible d'écrire ça,
Python attend un nom d'argument, pas une variable.
On peut par contre écrire :
Code:

1 2 def calcul(f,k,tcycle = T_cycle[1]):
Pour donner à l'argument tcycle la valeur par défaut T_cycle[1]
On ne peut pas non plus (ou alors je suis passé à coté ^^)
Utiliser un argument comme valeur par défaut d'un autre argument ...

Pour ton problème, il faut écrire quelque chose du genre :
Code:

1 2 3 4 5 def calcul(t_cycle, f, k): # [...] le traitement Damage = t_cycle/N_cycle # [...] la suite du traitement
Ce dont mont29 parle, c'est de remplacer les lignes
Code:

1 2 3 4 nb_loadcase = 9 i = 1 while i <= nb_loadcase:
par la ligne :
Code:

1 2 for i in range(1,10):
(à savoir que si i est un entier et que l'incrémentation devient grande,
Il est alors préférable d'utiliser la fonction xrange en lieu et place de range (même paramètres ^^))

Oui, il y a effectivement quelques “petits” problèmes… :mouarf:

Bon, tout d’abords, une fonction n’a pas accès aux variables du code qui l’appelle, autrement dit, dans ton code, calcul() ne connaît absolument pas Stress, par exemple. Il faut donc le lui passer en paramètre. Il faut également lui passer en paramètre le choix de la méthode ''Goodman' etc.).

Je conseille aussi d’ordonner les paramètres d’une fonction par ordre d’importance (grossièrement), donc j’ai placé le i (ou k) en premier.

Ensuite, quand tu passes une simple chaîne de caractères comme f, j’imagine qu’en fait tu veux que ce soit un nom de fichier (genre “f1”, “f2”, etc.)*?

Pour T_cycle, soit tu passes toute la liste à cacul(), qui se charge d’y récupérer la bonne valeur d’après k (ce que j’ai fait dans l’exemple ci-dessous), soit tu lui passes directement la bonne valeur, mais pas les deux*! :lol:

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
# define the list of target cycle of HCF
T_cycle = [28555200,28555200,19036800,590140800,28555200,38073600,76147200,95184000,47592000]
 
# calculate the static, dynamic and equivalent stresses
def calcul(k, T_cycle, Stress, Stress1, choix, f):
    maxStress=0
    for idx, value in enumerate(Stress) :
        S11 = value.data[0]
        S22 = value.data[1]
        S12 = value.data[3]
        e = Stress1[idx]
        S_11 = e.data[0]
        S_22 = e.data[1]
        S_12 = e.data[3]
        # calculate the dynamic stress tensor and its eigenvalues
        D11 = (S11-S_11)/2
        D22 = (S22-S_22)/2
        D12 = (S12-S_12)/2
        Dyn1 = ((D11+D22)-sqrt(D11**2+D22**2+4*D12**2-2*D11*D22))/2
        Dyn2 = ((D11+D22)+sqrt(D11**2+D22**2+4*D12**2-2*D11*D22))/2
        # calculate the static stress tensor and its eigenvalues
        St11 = (S11+S_11)/2
        St22 = (S22+S_22)/2
        St12 = (S12+S_12)/2
        Stat1 = ((St11+St22)+sqrt(St11**2+St22**2+4*St12**2-2*St11*St22))/2
        Stat2 = ((St11+St22)-sqrt(St11**2+St22**2+4*St12**2-2*St11*St22))/2
        # calculate the dynamic stress and the static stress
        if abs(Dyn1)>=abs(Dyn2):
            sig_dyn = Dyn1
        else:
            sig_dyn = Dyn2
 
        if abs(Stat1)>=abs(Stat2):
            signe = Stat1/abs(Stat1)
            sig_stat = signe*sqrt(Stat1**2-Stat1*Stat2+Stat2**2)
        else:
            signe = Stat2/abs(Stat2)
            sig_stat = signe*sqrt(Stat2**2-Stat1*Stat2+Stat1**2)
        Max = sig_dyn+sig_stat
        Min = sig_stat-sig_dyn
        R = Min/Max
        if choix == 'Goodman':
            alpha_G = abs(sig_D_mean/((sig_dyn/sig_stat)+(sig_D_mean/Rm)))*((1+(sig_dyn/sig_stat)**2)/(sig_dyn**2+sig_stat**2))**0.5
            sig_eq = sig_Goodman(Rm, sig_dyn, sig_stat, alpha_G)
        elif choix == 'Gerber':
            sig_eq = sig_Gerber(Re, sig_dyn, sig_stat)
        elif choix == 'Soderberg':
            alpha_S = abs(sig_D_mean/((sig_dyn/sig_stat)+(sig_D_mean/Re)))*((1+(sig_dyn/sig_stat)**2)/(sig_dyn**2+sig_stat**2))**0.5
            sig_eq = sig_Soderberg(Re, sig_dyn, sig_stat, alpha_S)
        else:
            print ('Votre choix n appartient pas a la liste precedante')
        if sig_eq > maxStress:
            maxStress = sig_eq
        if sig_eq > y[0]:
            N_cycle = 0
        elif sig_eq <= y[-1]:
            N_cycle = 1.0E+10
        else:
            i=0
            len_y=len(y)
            while (i < len_y - 1):
                if (sig_eq < y[i]) and (sig_eq > y[i+1]):
                    N_cycle = x[i+1]-((y[i+1]-sig_eq)*(x[i+1]-x[i])/(y[i+1]-y[i]))
                    break
                i=i+1
        Damage = T_cycle[k-1]/N_cycle
        if (R<-1) or (R>1):
            propa_DTA1=-1.0E-01
            propa_DTA2=-1.0E-01
            propa_FTA=-1.0E-01
        else:
            j =0
            len_DTA1 = len(DTA1)
            while (j < len_DTA1 - 1):
                if (R > Ratio[j]) and (R < Ratio[j+1]):
                    sig_DTA1 = DTA1[j+1]-((Ratio[j+1]-R)*(DTA1[j+1]-DTA1[j])/(Ratio[j+1]-Ratio[j]))
                    propa_DTA1 = sig_dyn-sig_DTA1
                    sig_DTA2 = DTA2[j+1]-((Ratio[j+1]-R)*(DTA2[j+1]-DTA2[j])/(Ratio[j+1]-Ratio[j]))
                    propa_DTA2 = sig_dyn-sig_DTA2
                    sig_FTA = FTA[j+1]-((Ratio[j+1]-R)*(FTA[j+1]-FTA[j])/(Ratio[j+1]-Ratio[j]))
                    propa_FTA = sig_dyn-sig_FTA
                    break
                j=j+1
 
        f.write('Instance:\t %s\tElement:\t %6d\tSig_stat:\t %E\tSig_dyn:\t %E\tMax:\t %E\tMin:\t %E\tR:\t %E\tSig_eq:\t %E\tN_cycle:\t %E\tMaxStress:\t %E\tDamage:\t %E\tpropa_DTA1:\t %E\tpropa_DTA2:\t %E\tpropa_FTA:\t %E\n'%(value.instance.name,value.elementLabel,sig_stat,sig_dyn,Max,Min,R,sig_eq,N_cycle,maxStress,Damage,propa_DTA1,propa_DTA2,propa_FTA))
 
 
#------------------------------------------------Analyse_frequentielle: HCF-------------------------------------------------------
 
nb_loadcase = 9
for i in range(1, nb_loadcase+1):
    print "HCF%i" %i
    # determine the stress value of the second step in the "SKIN" element set 
    stressField = odb.steps['Load'].frames[i+1].fieldOutputs['S']
    stressField1 = odb.steps['Load'].frames[i+2].fieldOutputs['S']
    topCenter = odb.rootAssembly.instances['V20110406-1-1'].elementSets['SKIN']
    Stress = stressField.getSubset(region=topCenter, position=CENTROID).values
    Stress1 = stressField1.getSubset(region=topCenter, position=CENTROID).values
    # Il faut bien un choix…
    choix = 'Goodman'
    # Je suppose que tu veux écrire chaque résultat du calcul dans un fichier f1, f2, etc.
    with open("f%i"%i, "w") as f:
        calcul(i, T_cycle, Stress, Stress1, choix, f)

Note que ce code ne marchera pas non plus tel-quel –*dans calcul, tu utilises encore des variables non-définies, comme Re, Rm et sig_D_mean, il faut soit que tu les y calcules, soit que tu les lui passes en paramètres…

PS*: Désolé pour le délai, mais ma connexion adsl est nase, aujourd’hui… :cry:

21/07/2011, 09h43
foufaa33

Bonjour,

merci beaucoup pour les réponses et les suggestions, ils m'ont aidée fortement.

Cordialement