reduire la longueur de script

Version imprimable

Bonjour,
j'ai créé un script qui fait la post-traitement d'une pièce mécanique simulée sur Abaqus (logiciel de simulation mécanique). mon script est fait pour un cas qui contient 9 types de chargements ( HCF1....... HCF9) mais parfois on veut simuler 50 types de chargements. mon problème est que je veux trouver une instruction qui peu reduoire la taille de script.
le script pour un seul cas de chargement 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
103
104
 
#-----------------------------------------------------------HCF1------------------------------------------------------------------
 
 
 
# determine the stress value at the second and third frame of the second step
# in the "SKIN" element set (HCF1)
stressField = odb.steps['Load'].frames[2].fieldOutputs['S']
stressField1 = odb.steps['Load'].frames[3].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
 
 
# calculate the static, dynamic and equivalent stresses
if choix=='Goodman':
    maxStress=0
    for idx, value in enumerate(Stress) :
        if abs(value.minPrincipal) >= abs(value.maxPrincipal):
            Max=value.minPrincipal
            #print ('Element: %6d\tMax: %E\n'%(value.elementLabel,value.minPrincipal))
        else:
            Max=value.maxPrincipal
            #print ('Element: %6d\tMax: %E\n'%(value.elementLabel,value.maxPrincipal))
        e = Stress1[idx]
        if abs(e.minPrincipal) >= abs(e.maxPrincipal):
            Min=e.minPrincipal
            #print ('Element: %6d\tMin: %E\n'%(value.elementLabel,e.minPrincipal))
        else:
            Min=e.maxPrincipal
            #print ('Element: %6d\tMin: %E\n'%(value.elementLabel,e.maxPrincipal))
        if Min > Max:
            Max1=Max
            Max=Min
            Min=Max1
        R = Min/Max
        sig_stat= (Max + Min)/2
        sig_dyn= (Max - Min)/2
        #print ('sig_stat: %E\tsig_dyn: %E\n'%(sig_stat,sig_dyn))
        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_Goodman = (Rm*sig_dyn)/(Rm-(sig_stat/alpha_G))
        if sig_eq_Goodman > maxStress:
            maxStress = sig_eq_Goodman
        if sig_eq_Goodman > y[0]:
            N_cycle = 0
        elif sig_eq_Goodman <= y[-1]:
            N_cycle = 1.0E+10
        else:
            i=0
            len_y=len(y)
            while (i < len_y - 1):
                if (sig_eq_Goodman < y[i]) and (sig_eq_Goodman > y[i+1]):
                    N_cycle = x[i+1]-((y[i+1]-sig_eq_Goodman)*(x[i+1]-x[i])/(y[i+1]-y[i]))
                    break
                i=i+1
        #print ('N_cycle : %E\n'%(N_cycle))
        T_cycle_HCF1 = 28555200
        Damage = T_cycle_HCF1/N_cycle
        f1.write('Instance:\t %s\tElement:\t %6d\tMax:\t %E\tMin:\t %E\tR:\t %E\tSig_stat:\t %E\tSig_dyn:\t %E\tSig_eq_Goodman:\t %E\tN_cycle:\t %E\tMaxStress:\t %E\tDamage:\t %E\n'%(value.instance.name,value.elementLabel,Max,Min,R,sig_stat,sig_dyn,sig_eq_Goodman,N_cycle,maxStress,Damage))
 
 
elif choix=='Gerber':
    maxStress=0
    for idx, value in enumerate(Stress) :
        if abs(value.minPrincipal) >= abs(value.maxPrincipal):
            Max=value.minPrincipal
            #print ('Element: %6d\tMax: %E\n'%(value.elementLabel,value.minPrincipal))
        else:
            Max=value.maxPrincipal
            #print ('Element: %6d\tMax: %E\n'%(value.elementLabel,value.maxPrincipal))
        e = Stress1[idx]
        if abs(e.minPrincipal) >= abs(e.maxPrincipal):
            Min=e.minPrincipal
            #print ('Element: %6d\tMin: %E\n'%(value.elementLabel,e.minPrincipal))
        else:
            Min=e.maxPrincipal
            #print ('Element: %6d\tMin: %E\n'%(value.elementLabel,e.maxPrincipal))
        if Min > Max:
            Max1=Max
            Max=Min
            Min=Max1
        R = Min/Max
        sig_stat= (Max + Min)/2
        sig_dyn= (Max - Min)/2
        #print ('sig_stat: %E\tsig_dyn: %E\n'%(sig_stat,sig_dyn))
        sig_eq_Gerber = ((Re**2)*sig_dyn)/(Re**2-(sig_stat)**2)
        if sig_eq_Goodman > maxStress:
            maxStress = sig_eq_Goodman
        if sig_eq_Gerber > y[0]:
            N_cycle = 0
        elif sig_eq_Gerber <= y[-1]:
            N_cycle = 1.0E+10
        else:
            i=0
            len_y=len(y)
            while (i < len_y - 1):
                if (sig_eq_Gerber < y[i]) and (sig_eq_Gerber > y[i+1]):
                    N_cycle = x[i+1]-((y[i+1]-sig_eq_Gerber)*(x[i+1]-x[i])/(y[i+1]-y[i]))
                    break
                i=i+1         
        #print ('N_cycle : %E\n'%(N_cycle))
        T_cycle_HCF1 = 28555200
        Damage = T_cycle_HCF1/N_cycle
        f1.write('Instance:\t %s\tElement:\t %6d\tMax:\t %E\tMin:\t %E\tR:\t %E\tSig_stat:\t %E\tSig_dyn:\t %E\tSig_eq_Gerber:\t %E\tN_cycle:\t %E\tMaxStress:\t %E\tDamage:\t %E\n'%(value.instance.name,value.elementLabel,Max,Min,R,sig_stat,sig_dyn,sig_eq_Gerber,N_cycle,maxStress,Damage))

je veux éviter de réécrire le trois conditions 'Goodman' 'Gerber' et 'Soderberg' car la seule différence dans ces trois boucles est au niveau des équations suivantes :

Code:

1
2
3
 
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_Goodman = (Rm*sig_dyn)/(Rm-(sig_stat/alpha_G))

Code:

1
2
 
sig_eq_Gerber = ((Re**2)*sig_dyn)/(Re**2-(sig_stat)**2)

Code:

1
2
3
 
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_Soderberg = (Re*sig_dyn)/(Re-(sig_stat/alpha_S))

mais les autres instructions sont les mêmes .

je suis bloquée à ce niveau parce que je suis débutante en Python et je connais pas comment créer un script efficace et réduit.

merci d'avance.
Cordialement

une autre proposition :
les différences entre les cas de chargement (HCF1... HCF9) sont le suivantes:
pour HCF1 on a :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #-----------------------------------------------------------HCF1------------------------------------------------------------------ # determine the stress value at the second and third frame of the second step # in the "SKIN" element set (HCF1) stressField = odb.steps['Load'].frames[2].fieldOutputs['S'] stressField1 = odb.steps['Load'].frames[3].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
pour HCF2 on a:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #-----------------------------------------------------------HCF2------------------------------------------------------------------ # determine the stress value at the forth and fifth frame of the second step # in the "SKIN" element set (HCF2) stressField2 = odb.steps['Load'].frames[4].fieldOutputs['S'] stressField3 = odb.steps['Load'].frames[5].fieldOutputs['S'] topCenter = odb.rootAssembly.instances['V20110406-1-1'].elementSets['SKIN'] Stress = stressField2.getSubset(region=topCenter, position=CENTROID).values Stress1 = stressField3.getSubset(region=topCenter, position=CENTROID).values
est ce que je peux créer une boucle for pour calculer HCFi quelque soit i est petit ou grand ?
ou encore une fonction qui remplace les trois boucles if dans chaque HCFi et à chaque fois où j'ai créé un HCFi je fais juste un appel de cette fonction. c'est plus efficace que réécrire plusieurs fois les même instructions pour chaque HCFi
je préfère la dernière proposition car je veux moi même définir les frames pour chaque HCF
merci

13/07/2011, 11h39
rambc

Bonjour,
je ne vais pas te donner la solution mais une méthode. En programmation, on parle d'abstraction. Cette technique consiste à repérer les méthodes utilisées plusieurs fois. On en fait alors une méthode générale qui sera appelée à différents endroits.

Par exemple, dans l'un de mes projets, je dois afficher des erreurs. Ma première solution a été d'écrire des print("Bla, bla..."). Ensuite je me suis dit qu'il y aurait en fait intérêt à écrire les messages dans un fichier LOG. J'ai donc décider de créer une fonction pour imprimer mes messages, et du coup en cas de changement de comportement, je n'ai qu'un seul endroit à modifier.

Tu peux aussi te poser la question de l'efficacité de ton algorithme, là cela devient tout un art de simplifier au maximum.

Bonjour,

pourquoi ne pas regrouper ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def sig_Goodman(Rm, sig_dyn, sig_stat, alpha_G)
    return (Rm*sig_dyn)/(Rm-(sig_stat/alpha_G))
 
def sig_Gerber(Re, sig_dyn, sig_stat):
    return ((Re**2)*sig_dyn)/(Re**2-(sig_stat)**2)
 
....
maxStress=0
....
    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_Goodman = sig_Goodman(Rm, sig_dyn, sig_stat, alpha_G)
    elif choix == 'Gerber':
        sig_eq_Gerber = sig_Gerber(Re, sig_dyn, sig_stat)
    if sig_eq_Goodman > maxStress:
        maxStress = sig_eq_Goodman
    if sig_eq_Gerber > y[0]:
        N_cycle = 0
....

Pour ta première question, comme le dit PauseKawa, il faut regrouper («*factoriser*») –*mais pourquoi conserver deux noms (sig_eq_Goodman et sig_eq_Gerber)*? Ces deux valeurs sont utilisées exactement de la même façon, si je ne m’abuse –*et pas besoin de fonctions additionnelles pour les calculer, à mon avis.

De plus, si je comprends bien, les seules différences entre les HCFx sont les indices utilisés pour récupérer les stressFields, donc en englobant le tout dans une bête fonction prenant entre autre paramètre le niveau de HCF, ça devrait le faire (factorisation, encore et toujours ;) )*:

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
#-----------------------------------------------------------HCFx------------------------------------------------------------------
 
# determine the stress value at the second and third frame of the second step
# in the "SKIN" element set (HCFx).
# level: the HCF level.
def get_hcfx(odb, level, choix, y):
    stressField = odb.steps['Load'].frames[2*level].fieldOutputs['S']
    stressField1 = odb.steps['Load'].frames[2*level+1].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
 
 
    # calculate the static, dynamic and equivalent stresses
 
    maxStress=0
    for idx, value in enumerate(Stress) :
        if abs(value.minPrincipal) >= abs(value.maxPrincipal):
            Max=value.minPrincipal
            #print ('Element: %6d\tMax: %E\n'%(value.elementLabel,value.minPrincipal))
        else:
            Max=value.maxPrincipal
            #print ('Element: %6d\tMax: %E\n'%(value.elementLabel,value.maxPrincipal))
        e = Stress1[idx]
        if abs(e.minPrincipal) >= abs(e.maxPrincipal):
            Min=e.minPrincipal
            #print ('Element: %6d\tMin: %E\n'%(value.elementLabel,e.minPrincipal))
        else:
            Min=e.maxPrincipal
            #print ('Element: %6d\tMin: %E\n'%(value.elementLabel,e.maxPrincipal))
        if Min > Max:
            Max1=Max
            Max=Min
            Min=Max1
        R = Min/Max
        sig_stat= (Max + Min)/2
        sig_dyn= (Max - Min)/2
        #print ('sig_stat: %E\tsig_dyn: %E\n'%(sig_stat,sig_dyn))
        sig_eq = 0.0
        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 = (Rm*sig_dyn)/(Rm-(sig_stat/alpha_G))
        elif choix=='Gerber':
            sig_eq = ((Re**2)*sig_dyn)/(Re**2-(sig_stat)**2)
        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
        #print ('N_cycle : %E\n'%(N_cycle))
        T_cycle_HCF1 = 28555200
        Damage = T_cycle_HCF1/N_cycle
        if choix=='Goodman':
            f1.write('Instance:\t %s\tElement:\t %6d\tMax:\t %E\tMin:\t %E\tR:\t %E\tSig_stat:\t %E\tSig_dyn:\t %E\tSig_eq_Goodman:\t %E\tN_cycle:\t %E\tMaxStress:\t %E\tDamage:\t %E\n'%(value.instance.name,value.elementLabel,Max,Min,R,sig_stat,sig_dyn,sig_eq,N_cycle,maxStress,Damage))
        elif choix=='Gerber':
            f1.write('Instance:\t %s\tElement:\t %6d\tMax:\t %E\tMin:\t %E\tR:\t %E\tSig_stat:\t %E\tSig_dyn:\t %E\tSig_eq_Gerber:\t %E\tN_cycle:\t %E\tMaxStress:\t %E\tDamage:\t %E\n'%(value.instance.name,value.elementLabel,Max,Min,R,sig_stat,sig_dyn,sig_eq,N_cycle,maxStress,Damage))

PS*: Y’avait une petite erreur d’inattention, dans ton code (sig_eq_Goodman à la place de sig_eq_Gerber, l.87 et 88), non*?

PPS*: Tu peux expliquer rapidement à quoi correspondent ces calculs*? Mes connaissances en physique des matériaux (si c’est bien de ça qu’il s’agit) frôlent le zéro absolu… :oops:

Citation:

Envoyé par mont29

*mais pourquoi conserver deux noms (sig_eq_Goodman et sig_eq_Gerber)*? Ces deux valeurs sont utilisées exactement de la même façon, si je ne m’abuse –*et pas besoin de fonctions additionnelles pour les calculer, à mon avis.

C'est ce que je suppose aussi mais
Code:

1 2 3 4 5 6 if sig_eq_Goodman > maxStress: maxStress = sig_eq_Goodman if sig_eq_Gerber > y[0]: N_cycle = 0 elif sig_eq_Gerber <= y[-1]: N_cycle = 1.0E+10
Sauf si c'est une erreur bien sur.

13/07/2011, 16h17
mont29

Ben à mon avis, ça ne peut être qu’une erreur, puisque sig_eq_Goodman n’est défini que dans la branche “if choix == 'Goodman':”, donc n’existe pas si choix vaut "Gerber"…