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 : 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
 
#-----------------------------------------------------------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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
sig_eq_Gerber = ((Re**2)*sig_dyn)/(Re**2-(sig_stat)**2)
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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