1 #@ MODIF impr_diag_campbell_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
3 # CONFIGURATION MANAGEMENT OF EDF VERSION
4 # ======================================================================
5 # COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG
6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
9 # (AT YOUR OPTION) ANY LATER VERSION.
11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
18 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
19 # ======================================================================
20 # RESPONSABLE Mohamed TORKHANI
24 def impr_diag_campbell_ops(self, MAILLAGE, MODES, NFREQ_camp, TYP_PREC, TYP_TRI,
25 UNIT_FLE, UNIT_TOR, UNIT_LON, UNIT_TOT, UNIT_INT,L_S, **args) :
26 # Macro permettant de tracer le diagramme de Campbell suivant
27 # le type de suivi des modes et le type de calcul de la precession
28 #Type de suivi, 0 SANS_TRI, 1 TRI_PREC, 2 TRI_FORM_MOD
29 #Type de precession, 1 somme, 2 grande orbite
35 from Noyau.N_types import is_float
37 from Macro.impr_diag_campbell_utils import (
38 CLASS_MODES, EXTR_FREQ, TRI_MODE_MACf, TRI_MODE_MACt, TRI_MODE_MACl, CALC_MACf,
39 CALC_MACt, CALC_MACl, CALC_PREC, TRI_MODE_PREC_DI, affiche_tab, affiche_tabint,
40 calc_pas, color_camp, sup_redon_list, sup_redon_listv, save_intersec
44 # On importe les definitions des commandes a utiliser dans la macro
46 POST_RELEVE_T =self.get_cmd('POST_RELEVE_T')
47 EXTR_MODE =self.get_cmd('EXTR_MODE')
48 NORM_MODE =self.get_cmd('NORM_MODE')
49 RECU_TABLE =self.get_cmd('RECU_TABLE')
50 MAC_MODES =self.get_cmd('MAC_MODES')
51 DEFI_LIST_REEL =self.get_cmd('DEFI_LIST_REEL')
52 DEFI_FONCTION =self.get_cmd('DEFI_FONCTION')
53 EXTR_TABLE =self.get_cmd('EXTR_TABLE')
54 IMPR_FONCTION =self.get_cmd('IMPR_FONCTION')
55 IMPR_RESU =self.get_cmd('IMPR_RESU')
56 IMPR_TABLE =self.get_cmd('IMPR_TABLE')
57 DEFI_FICHIER =self.get_cmd('DEFI_FICHIER')
58 DETRUIRE =self.get_cmd('DETRUIRE')
61 # La macro compte pour 1 dans la numerotation des commandes
66 # Extraire les vitesses de rotation
70 print 'nb_temp', nb_temp
71 lvit[nb_temp] = MODES['VITE_ROTA' ,nb_temp+1];
77 VITE_ROTA = lvit[0:nb_temp];
78 num_vit_tri=sup_redon_listv(VITE_ROTA);
79 # Recupere les modes suivant l'ordre de la liste des vitesses de rotation
82 for ii in range(0,nbV1):
83 itri = num_vit_tri[ii];
84 lmo[ii]=EXTR_TABLE(TYPE_RESU='MODE_MECA',
87 FILTRE=_F(NOM_PARA='NUME_VITE',VALE_I=itri),);
91 if type(VITE_ROTA)==list:
93 elif type(VITE_ROTA)==tuple:
94 L_VIT1=list(VITE_ROTA);
95 elif is_float(VITE_ROTA):
96 L_VIT1.append(VITE_ROTA);
102 aster.affiche('RESULTAT', chaine)
103 chaine='Liste triee des vitesses en rad/s'
104 aster.affiche('RESULTAT', chaine)
105 for ii in range(nbV):
106 chaine= '%15.5E' %L_VIT1[ii];
107 aster.affiche('RESULTAT', chaine)
110 #-------------------------------------------------------------------------
111 # Tester le nombre de frequences calculees pour chaque vitesse de rotation
112 #-------------------------------------------------------------------------
115 for ii in range(nbV):
117 tabfreq = RECU_TABLE(CO= lmo[ii],NOM_PARA='FREQ',);
118 tab2=tabfreq.EXTR_TABLE();
120 nb_FREQ_prec=nb_FREQ;
121 nb_FREQ.append(len(tabf));
123 DETRUIRE(CONCEPT=_F(NOM=(tabfreq)),INFO=1)
125 nbf_max=max(nb_FREQ);
126 nbf_min=min(nb_FREQ);
130 aster.affiche('RESULTAT', chaine)
131 chaine='Les nombres de frequences sont differents pour les vitesses de rotation.'
132 aster.affiche('RESULTAT', chaine)
133 chaine='Pour poursuivre le calcul, NFREQ = %d' %NFREQ
134 aster.affiche('RESULTAT', chaine)
137 aster.affiche('RESULTAT', chaine)
138 chaine='Nombre de valeurs propres detectees est %d' %NFREQ
139 aster.affiche('RESULTAT', chaine)
140 if NFREQ_camp > NFREQ:
141 chaine='Nombre de frequences demandees pour le trace %d' %NFREQ_camp
142 aster.affiche('RESULTAT', chaine)
143 NFREQ_camp = NFREQ-4;
144 chaine='Nombre de frequences pour le trace %d' %NFREQ_camp
145 aster.affiche('RESULTAT', chaine)
147 chaine='Nombre de frequences demandees pour le trace %d' %NFREQ_camp
148 aster.affiche('RESULTAT', chaine)
150 chaine='Le trace du diagramme de Campbell s''arrete !.'
151 aster.affiche('RESULTAT', chaine)
156 # ------------------------------------------------------------------
157 # Classe les modes en flexion, en torsion , en traction/ compression
158 # ------------------------------------------------------------------
164 # Recuperer les noeuds du maillage
165 # construction des vecteurs jeveux
166 nom_mail=MAILLAGE.nom
168 nom_mail=nom_mail+' '*(8-lenm)
169 vectnoeu=nom_mail+'.NOMNOE'
170 L_GR_NOEUD=aster.getvectjev(vectnoeu)
173 NOEU=len(L_GR_NOEUD);
174 C_MODES=CLASS_MODES(self,lmo,NFREQ,NFREQ_camp,L_GR_NOEUD,L_VIT1);
183 # Initialisation des tableaux de connexion apres classement
184 # en gardant la numerotation globale des modes
189 NFREQ_fc=C_MODES[10];
190 NFREQ_tc=C_MODES[11];
191 NFREQ_lc=C_MODES[12];
194 aster.affiche('RESULTAT', chaine)
195 chaine='Nombre de frequences totale :' + str(NFREQ)
196 aster.affiche('RESULTAT', chaine)
197 chaine='Nombre de frequences en flexion :' + str(NFREQ_f) + ' ' + str(NFREQ_fc)
198 aster.affiche('RESULTAT', chaine)
199 chaine='Nombre de frequences torsion :' + str(NFREQ_t) + ' ' + str(NFREQ_tc)
200 aster.affiche('RESULTAT', chaine)
201 chaine='Nombre de frequences traction/compression :' + str(NFREQ_l) + ' ' + str(NFREQ_lc)
202 aster.affiche('RESULTAT', chaine)
205 aster.affiche('RESULTAT', chaine)
206 chaine='Initialisation des tableaux de connexion'
207 aster.affiche('RESULTAT', chaine)
208 chaine='Modes non classes'
209 aster.affiche('RESULTAT', chaine)
210 affiche_tabint(NVT,NFREQ, nbV);
212 chaine='Modes de flexion'
213 aster.affiche('RESULTAT', chaine)
214 affiche_tabint(NVTf_int,NFREQ_f, nbV);
216 chaine='Modes de torsion'
217 aster.affiche('RESULTAT', chaine)
218 affiche_tabint(NVTt_int,NFREQ_t, nbV);
220 chaine='Modes de traction/compression'
221 aster.affiche('RESULTAT', chaine)
222 affiche_tabint(NVTl_int,NFREQ_l, nbV);
224 #-----------------------
225 #Extraire les frequences
226 #-----------------------
227 FREQ=EXTR_FREQ(self,lmo,Mf,Mt,Ml, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l);
236 aster.affiche('RESULTAT', chaine)
237 chaine='Frequences totales'
238 aster.affiche('RESULTAT', chaine)
239 affiche_tab(FRQ,NFREQ, nbV);
242 aster.affiche('RESULTAT', chaine)
243 chaine='Frequences en flexion'
244 aster.affiche('RESULTAT', chaine)
245 affiche_tab(FRQf,NFREQ_f, nbV);
247 aster.affiche('RESULTAT', chaine)
248 chaine='Amortissement reduit'
249 aster.affiche('RESULTAT', chaine)
250 affiche_tab(AMOf,NFREQ_f, nbV);
252 aster.affiche('RESULTAT', chaine)
254 chaine='Frequences en torsion'
255 aster.affiche('RESULTAT', chaine)
256 affiche_tab(FRQt,NFREQ_t, nbV);
258 aster.affiche('RESULTAT', chaine)
260 chaine='Frequences en traction/compression'
261 aster.affiche('RESULTAT', chaine)
262 affiche_tab(FRQl,NFREQ_l, nbV);
264 # Initialisation des tableaux de connexion
265 # nouveau numerotation de modes par type de mode
268 NVTf =numpy.zeros((NFREQ_f, nbV), int);
269 for ii in range(nbV):
270 for jj in range(NFREQ_f):
273 aster.affiche('RESULTAT', chaine)
274 chaine='Tableau de connexion initial en flexion'
275 aster.affiche('RESULTAT', chaine)
276 affiche_tabint(NVTf,NFREQ_f, nbV);
279 NVTt =numpy.zeros((NFREQ_t, nbV), int);
280 for ii in range(nbV):
281 for jj in range(NFREQ_t):
284 aster.affiche('RESULTAT', chaine)
285 chaine='Tableau de connexion initial en torsion'
286 aster.affiche('RESULTAT', chaine)
287 affiche_tabint(NVTt,NFREQ_t, nbV);
290 NVTl =numpy.zeros((NFREQ_l, nbV), int);
291 for ii in range(nbV):
292 for jj in range(NFREQ_l):
295 aster.affiche('RESULTAT', chaine)
296 chaine='Tableau de connexion initial en traction/compression'
297 aster.affiche('RESULTAT', chaine)
298 affiche_tabint(NVTl,NFREQ_l, nbV);
300 # ------------------------------------------------------------------
301 # Tri par forme des modes
302 # Tri des frequences par calcul des coefficients MAC
303 # Remplissage du tableau de connexion
304 # ------------------------------------------------------------------
306 # ------------------------------------------------------------------
307 # Calcul de la matrice MAC entre les bases successives en flexion
308 # ------------------------------------------------------------------
310 LMACf=CALC_MACf(self, Mf, NFREQ_f) ;
312 aster.affiche('RESULTAT', chaine)
313 chaine=' Tri par forme des modes TRI_FORM_MOD'
314 aster.affiche('RESULTAT', chaine)
316 for ii in range(nbV-1):
318 aster.affiche('RESULTAT', chaine)
320 NVTf_mac=TRI_MODE_MACf(self, LMACf[iv],NFREQ_f, NVTf, iv);
324 for ii in range(NFREQ_f):
325 NVTf_mac[ii][0]=NVTf_mac[ii][1] ;
328 aster.affiche('RESULTAT', chaine)
329 chaine='Tableau de connexion en flexion'
330 aster.affiche('RESULTAT', chaine)
331 affiche_tabint(NVTf_mac,NFREQ_f, nbV);
333 # ------------------------------------------------------------------
334 # Calcul de la matrice MAC entre les bases successives en torsion
335 # ------------------------------------------------------------------
337 LMACt=CALC_MACt(self, Mt, NFREQ_t) ;
339 for ii in range(nbV-1):
341 aster.affiche('RESULTAT', chaine)
343 NVTt=TRI_MODE_MACt(self, LMACt[iv],NFREQ_t, NVTt, iv);
345 aster.affiche('RESULTAT', chaine)
346 chaine='Tableau de connexion en torsion'
347 aster.affiche('RESULTAT', chaine)
348 affiche_tabint(NVTt,NFREQ_t, nbV);
350 # ----------------------------------------------------------------------------
351 # Calcul de la matrice MAC entre les bases successives en traction/compression
352 # ----------------------------------------------------------------------------
354 LMACl=CALC_MACl(self, Ml, NFREQ_l) ;
356 for ii in range(nbV-1):
358 aster.affiche('RESULTAT', chaine)
360 NVTl=TRI_MODE_MACl(self, LMACl[iv],NFREQ_l, NVTl, iv);
362 aster.affiche('RESULTAT', chaine)
363 chaine='Tableau de connexion en traction/compression'
364 aster.affiche('RESULTAT', chaine)
365 affiche_tabint(NVTl,NFREQ_l, nbV);
368 #--------------------------------------------------------------------------
369 # Calcul le sens de precession pour les modes en flexion a une vitesse de rotation donnee
370 #--------------------------------------------------------------------------
372 SENS=CALC_PREC(self, Mf,NFREQ_f,L_GR_NOEUD, TYP_PREC);
375 aster.affiche('RESULTAT', chaine)
376 chaine='Sens de precession pour les modes en flexion'
377 aster.affiche('RESULTAT', chaine)
378 affiche_tab(SENS,NFREQ_f, nbV);
380 # ------------------------------------------------------------------
381 # Tri des modes en flexion par une methode de proche en proche
382 # avec verification du sens de precession
383 # Remplissage du tableau de connexion
384 # ------------------------------------------------------------------
388 PREC_DI=TRI_MODE_PREC_DI (SENS,NFREQ_f, NVTf, nbV, OMIN);
389 nb_prec_dir=PREC_DI[0];
390 nb_prec_inv=PREC_DI[1];
391 NVTf_prec=PREC_DI[2];
395 # --------------------------------
396 # Trace du diagramme de campbell
397 # --------------------------------
398 chaine='Trace du diagramme de campbell'
399 aster.affiche('RESULTAT', chaine)
401 #Conversion de la vitesse de rotation en tr/mn pour l'affichage
403 for ii in range(nbV):
404 OM[ii] = OM[ii]*30./pi;
406 Vitesse_min = min(OM);
407 Vitesse_max = max(OM);
409 OM_int=[OM[ii] for ii in range(len(OM))]; # pour le calcul des points d'intersection
411 legende_x= 'Vitesse (tr/mn)';
413 if abs(Vitesse_min) > abs(Vitesse_max):
414 legende_x= 'Vitesse negative, en abscisse la valeur absolue de la vitesse (tr/mn)';
415 for ii in range(nbV):
416 OM[ii] = abs(OM[ii]);
418 __FX=DEFI_LIST_REEL(VALE=OM);
420 # Mise en page graphique
426 # Determination de la frequence maximale
428 for jf in range(NFREQ_fc):
429 for iv in range(nbV):
433 jf1=NVTf_prec[jf][iv]-1;
435 jf1=NVTf_mac[jf][iv]-1;
440 for jf in range(NFREQ_tc):
441 for iv in range(nbV):
447 for jf in range(NFREQ_lc):
448 for iv in range(nbV):
457 # Calcul des bornes et pas de la grille pour les vitesses de rotation
458 BV = calc_pas(Vmin, Vmax);
463 print 'BVmin, BVmax, pasV', BVmin, BVmax, pasV
464 # Calcul des bornes et pas de la grille pour les frequences
465 BF = calc_pas(Fmin, Fmax);
471 aster.affiche('RESULTAT', chaine)
472 chaine='Fmax ' + str(Fmax) + ' BFmax ' + str(BFmax)
473 aster.affiche('RESULTAT', chaine)
475 TITRE1 = 'Diagramme de Campbell';
476 TITRE2 = 'Modes en flexion'
478 DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_FLE,)
479 DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_TOR,)
480 DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_LON,)
481 DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_TOT,)
482 # ---------------------------------------------------
483 # Trace du diagramme de campbell des modes en flexion
484 # ---------------------------------------------------
491 for jf in range(NFREQ_fc):
492 for iv in range(nbV-1):
493 OM3 = -1. # OM3 different de -1, Changement de precession
494 OM4 = -1. # OM4 different de -1, Changement de stabilite
497 jf2=NVTf[jf][iv+1]-1;
499 jf1=NVTf_prec[jf][iv]-1;
500 jf2=NVTf_prec[jf][iv+1]-1;
502 jf1=NVTf_mac[jf][iv]-1;
503 jf2=NVTf_mac[jf][iv+1]-1;
506 if jf1>=0 and jf2>=0:
520 if S1*S2<0 : # Changement de precession
524 A0 = abs(EPSI*(F1+F2)/2)
525 if ((A1-A0)*(A2-A0) <0): # Changement de stabilite
526 OM4 = (A2*OM1 - A1*OM2) / (A2 -A1)
527 aa = (F2 - F1) / (OM2 -OM1)
528 bb = (F2*OM1 - F1*OM2) / (OM1 -OM2)
531 # OM4 en dehors de OM1, OM2
538 if (A1 <0) and (abs(A1) < A0):
540 if (A2 <0) and (abs(A2) < A0):
543 # Tracer le segment pour chaque intervalle avec le code de couleur et
546 # 1 cas, Pas de changement sur la plage de vitesse
547 if ((OM3 == -1) and (OM4 == -1)):
548 FX1=DEFI_LIST_REEL(VALE=[OM1,OM2]);
549 FY1=DEFI_LIST_REEL(VALE=[F1,F2]);
550 CS2=color_camp(S2,A1);
557 FON1[ll]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
560 DICO["FONCTION"]=FON1[ll];
561 DICO["COULEUR"] =ICS2;
563 DICO["MARQUEUR"]=IMA2;
567 DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1)),INFO=1);
569 # 2 cas, Changement de sens de precession
570 elif (OM3 >=0) and (OM4 == -1):
571 FX1=DEFI_LIST_REEL(VALE=[OM1,OM3]); # Premiere partie
572 FY1=DEFI_LIST_REEL(VALE=[F1,F3]);
573 FX2=DEFI_LIST_REEL(VALE=[OM3,OM2]); # Deuxieme partie
574 FY2=DEFI_LIST_REEL(VALE=[F3,F2]);
575 CS1=color_camp(S1,A1);
579 CS2=color_camp(S2,A1);
586 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
589 DICO["FONCTION"]=FON1[ll];
590 DICO["COULEUR"] =ICS1;
592 DICO["MARQUEUR"]=IMA1;
598 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
601 DICO["FONCTION"]=FON1[ll];
602 DICO["COULEUR"] =ICS2;
604 DICO["MARQUEUR"]=IMA2;
608 DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2)),INFO=1);
610 # 3 cas, de changement de stabilite
611 elif (OM3 == -1) and (OM4 >= 0):
613 FX1=DEFI_LIST_REEL(VALE=[OM1,OM4]); # Premiere partie
614 FY1=DEFI_LIST_REEL(VALE=[F1,F4]);
615 FX2=DEFI_LIST_REEL(VALE=[OM4,OM2]); # Deuxieme partie
616 FY2=DEFI_LIST_REEL(VALE=[F4,F2]);
617 CS1=color_camp(S2,A1);
621 CS2=color_camp(S2,A2);
628 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
631 DICO["FONCTION"]=FON1[ll];
632 DICO["COULEUR"] =ICS1;
634 DICO["MARQUEUR"]=IMA1;
640 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
643 DICO["FONCTION"]=FON1[ll];
644 DICO["COULEUR"] =ICS2;
646 DICO["MARQUEUR"]=IMA2;
650 DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2)),INFO=1);
652 # 4 et 5 cas de changement de sens de precession et de stabilite
653 elif (OM3 >= 0) and (OM4 >= 0):
656 FX1=DEFI_LIST_REEL(VALE=[OM1,OM4]); # Premiere partie
657 FY1=DEFI_LIST_REEL(VALE=[F1,F4]);
658 FX2=DEFI_LIST_REEL(VALE=[OM4,OM3]); # Deuxieme partie
659 FY2=DEFI_LIST_REEL(VALE=[F4,F3]);
660 FX3=DEFI_LIST_REEL(VALE=[OM3,OM2]); # Troisieme partie
661 FY3=DEFI_LIST_REEL(VALE=[F3,F2]);
662 CS1=color_camp(S1,A1);
666 CS2=color_camp(S1,A2);
670 CS3=color_camp(S2,A2);
677 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
680 DICO["FONCTION"]=FON1[ll];
681 DICO["COULEUR"] =ICS1;
683 DICO["MARQUEUR"]=IMA1;
689 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
692 DICO["FONCTION"]=FON1[ll];
693 DICO["COULEUR"] =ICS2;
695 DICO["MARQUEUR"]=IMA2;
701 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX3,VALE_FONC=FY3);
704 DICO["FONCTION"]=FON1[ll];
705 DICO["COULEUR"] =ICS3;
707 DICO["MARQUEUR"]=IMA3;
711 DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2, FX3,FY3)),INFO=1);
715 FX1=DEFI_LIST_REEL(VALE=[OM1,OM3]); # Premiere partie
716 FY1=DEFI_LIST_REEL(VALE=[F1,F3]);
717 FX2=DEFI_LIST_REEL(VALE=[OM3,OM4]); # Deuxieme partie
718 FY2=DEFI_LIST_REEL(VALE=[F3,F4]);
719 FX3=DEFI_LIST_REEL(VALE=[OM4,OM2]); # Troisieme partie
720 FY3=DEFI_LIST_REEL(VALE=[F4,F2]);
721 CS1=color_camp(S1,A1);
725 CS2=color_camp(S2,A1);
729 CS3=color_camp(S2,A2);
736 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
739 DICO["FONCTION"]=FON1[ll];
740 DICO["COULEUR"] =ICS1;
742 DICO["MARQUEUR"]=IMA1;
748 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
751 DICO["FONCTION"]=FON1[ll];
752 DICO["COULEUR"] =ICS2;
754 DICO["MARQUEUR"]=IMA2;
760 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX3,VALE_FONC=FY3);
762 DICO["FONCTION"]=FON1[ll];
763 DICO["COULEUR"] =ICS3;
765 DICO["MARQUEUR"]=IMA3;
769 DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2, FX3, FY3)),INFO=1);
773 mfac1["COURBE"]=LFONC;
778 BORNE_X = (BVmin,BVmax),
779 BORNE_Y = (BFmin,BFmax),
784 LEGENDE_X = legende_x,
785 LEGENDE_Y = 'FREQ (Hz)',
791 BORNE_X = (BVmin,BVmax),
792 BORNE_Y = (BFmin,BFmax),
797 LEGENDE_X = legende_x,
798 LEGENDE_Y = 'FREQ (Hz)',
801 for ii in range(nbll):
802 DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
808 # ---------------------------------------------------
809 # Trace du diagramme de campbell des modes en torsion
810 # ---------------------------------------------------
811 TITRE2 = 'Modes en Torsion'
816 for jj in range(NFREQ_tc):
818 FY1=DEFI_LIST_REEL(VALE=[FRQt[int(NVTt[jj][ii]-1)][ii] for ii in range(nbV)]);
819 FON1[jj]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=__FX,VALE_FONC=FY1);
823 DICO["FONCTION"]=FON1[jj];
830 DETRUIRE(CONCEPT=_F(NOM=(FY1)),INFO=1);
832 mfac1["COURBE"]=LFONC;
836 BORNE_X =(BVmin,BVmax),
837 BORNE_Y =(BFmin,BFmax),
842 LEGENDE_X = legende_x,
843 LEGENDE_Y = 'FREQ (Hz)',
849 BORNE_X =(BVmin,BVmax),
850 BORNE_Y =(BFmin,BFmax),
854 LEGENDE_X = legende_x,
855 LEGENDE_Y = 'FREQ (Hz)',
860 for ii in range(NFREQ_tc):
861 DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
866 # ----------------------------------------------------------------
867 # Trace du diagramme de campbell des modes en traction/compression
868 # ----------------------------------------------------------------
869 TITRE2 = 'Modes en traction/compression'
874 for jj in range(NFREQ_lc):
876 FY1=DEFI_LIST_REEL(VALE=[FRQl[int(NVTl[jj][ii]-1)][ii] for ii in range(nbV)]);
877 FON1[jj]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=__FX,VALE_FONC=FY1);
880 DICO["FONCTION"]=FON1[jj];
887 DETRUIRE(CONCEPT=_F(NOM=(FY1)),INFO=1);
889 mfac1["COURBE"]=LFONC;
893 BORNE_X =(BVmin,BVmax),
894 BORNE_Y =(BFmin,BFmax),
899 LEGENDE_X = legende_x,
900 LEGENDE_Y = 'FREQ (Hz)',
905 BORNE_X =(BVmin,BVmax),
906 BORNE_Y =(BFmin,BFmax),
910 LEGENDE_X = legende_x,
911 LEGENDE_Y = 'FREQ (Hz)',
916 for ii in range(NFREQ_lc):
917 DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
922 for jj in range(nbV):
923 DETRUIRE(CONCEPT=_F(NOM=(Mf[jj])),INFO=1)
925 for jj in range(nbV):
926 DETRUIRE(CONCEPT=_F(NOM=(Mt[jj])),INFO=1)
928 for jj in range(nbV):
929 DETRUIRE(CONCEPT=_F(NOM=(Ml[jj])),INFO=1)
933 #------------------------------------------------------------------------------------
935 # -----------------------------
936 # Trace des droites de pentes S
937 # -----------------------------
939 # Pour S=1, on le trace automatiquement
945 elif type(L_S)==tuple:
951 # Supprimer la redondance dans la liste
952 sup_redon_list(L_S1);
955 # Faire une dictionnaire de courbe
956 # Constituer de liste de dictionnaire de fonctions
960 for ii in range(len(L_S1)):
961 F1 =BVmin*L_S1[ii]/60.
962 F2 =BVmax*L_S1[ii]/60.
963 FX1=DEFI_LIST_REEL(VALE=[BVmin,BVmax]);
964 FY1=DEFI_LIST_REEL(VALE=[F1,F2]);
966 FON1[ii]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
969 DICO["FONCTION"]=FON1[ii];
976 DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1)),INFO=1);
978 mfac1["COURBE"]=LFONC;
980 TITRE2 = 'Modes en flexion'
984 BORNE_X = (BVmin,BVmax),
985 BORNE_Y = (BFmin,BFmax),
990 LEGENDE_X = legende_x,
991 LEGENDE_Y = 'FREQ (Hz)',
995 TITRE2 = 'Modes en Torsion'
999 BORNE_X = (BVmin,BVmax),
1000 BORNE_Y = (BFmin,BFmax),
1002 SOUS_TITRE = TITRE2,
1005 LEGENDE_X = legende_x,
1006 LEGENDE_Y = 'FREQ (Hz)',
1009 TITRE2 = 'Modes en traction/compression'
1013 BORNE_X = (BVmin,BVmax),
1014 BORNE_Y = (BFmin,BFmax),
1016 SOUS_TITRE = TITRE2,
1019 LEGENDE_X = legende_x,
1020 LEGENDE_Y = 'FREQ (Hz)',
1026 BORNE_X = (BVmin,BVmax),
1027 BORNE_Y = (BFmin,BFmax),
1031 LEGENDE_X = legende_x,
1032 LEGENDE_Y = 'FREQ (Hz)',
1035 for ii in range(len(L_S1)):
1036 DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
1041 DEFI_FICHIER ( ACTION='LIBERER', UNITE=UNIT_FLE,)
1042 DEFI_FICHIER ( ACTION='LIBERER', UNITE=UNIT_TOR,)
1043 DEFI_FICHIER ( ACTION='LIBERER', UNITE=UNIT_LON,)
1044 DEFI_FICHIER ( ACTION='LIBERER', UNITE=UNIT_TOT,)
1046 #------------------------------------------------------------------------------------
1048 # --------------------------------------------------------------
1049 # Determination des points d'intersection avec les droites Y=AX
1050 # Calcul des coordonnees des points
1051 # --------------------------------------------------------------
1054 # Ecrire dans un fichier texte en sortie
1055 DEFI_FICHIER(TYPE='ASCII', UNITE=UNIT_INT,);
1056 nomfic='fort.'+str(UNIT_INT);
1057 FINT1=open(nomfic, 'w')
1062 for ii in range(len(L_S1)):
1064 DICO["pente"]=L_S1[ii];
1067 for jf in range(NFREQ_fc):
1068 for iv in range(nbV-1):
1071 jf2=NVTf[jf][iv+1]-1;
1073 jf1=NVTf_prec[jf][iv]-1;
1074 jf2=NVTf_prec[jf][iv+1]-1;
1076 jf1=NVTf_mac[jf][iv]-1;
1077 jf2=NVTf_mac[jf][iv+1]-1;
1078 if jf1>=0 and jf2>=0:
1082 Y2 = FRQf[jf2][iv+1];
1083 A = (Y1-Y2)/(X1-X2);
1086 P1 = B*60./(pente-A*60.);
1089 if P1 >=X1 and P1<=X2:
1090 if P2 >= Fmin and P2<=Fmax :
1091 if OM_int[iv]<=0 and OM_int[iv+1]<0 : # Vitesse negative
1095 # On ajoute une ligne supplementaire
1096 XY.append([None]*2);
1102 INTERSEC.append(DICO);
1104 # Sauvegarde des points d'intersection
1106 chaine = 'Mode en flexion'
1108 save_intersec(INTERSEC, FINT1);
1115 for ii in range(len(L_S1)):
1117 DICO["pente"]=L_S1[ii];
1120 for jf in range(NFREQ_tc):
1121 for iv in range(nbV-1):
1123 jf2=NVTt[jf][iv+1]-1;
1124 if jf1>=0 and jf2>=0:
1128 Y2 = FRQt[jf2][iv+1];
1129 A = (Y1-Y2)/(X1-X2);
1132 P1 = B*60./(pente-A*60.);
1135 if P1 >=X1 and P1<=X2:
1136 if P2 >= Fmin and P2<=Fmax :
1137 if OM_int[iv]<=0 and OM_int[iv+1]<0 : # Vitesse negative
1141 # On ajoute une ligne supplementaire
1142 XY.append([None]*2);
1147 INTERSEC.append(DICO);
1149 # Sauvegarde des points d'intersection
1152 chaine = 'Mode en Torsion'
1154 save_intersec(INTERSEC, FINT1);
1160 #------------------------------------------------------------------------------------
1163 # Modes en traction / compression
1164 for ii in range(len(L_S1)):
1166 DICO["pente"]=L_S1[ii];
1169 for jf in range(NFREQ_lc):
1170 for iv in range(nbV-1):
1172 jf2=NVTl[jf][iv+1]-1;
1173 if jf1>=0 and jf2>=0:
1177 Y2 = FRQl[jf2][iv+1];
1178 A = (Y1-Y2)/(X1-X2);
1181 P1 = B*60./(pente-A*60.);
1184 if P1 >=X1 and P1<=X2:
1185 if P2 >= Fmin and P2<=Fmax :
1186 if OM_int[iv]<=0 and OM_int[iv+1]<0 : # Vitesse negative
1190 # On ajoute une ligne supplementaire
1191 XY.append([None]*2);
1196 INTERSEC.append(DICO);
1198 # Sauvegarde des points d'intersection
1201 chaine = 'Mode en traction / compression'
1203 save_intersec(INTERSEC, FINT1);
1208 for ii in range(nbl):