Aster/Cata/cataSTA10/Macro/impr_diag_campbell_ops.py

   1 #@ MODIF impr_diag_campbell_ops Macro  DATE 09/11/2010   AUTEUR TORKHANI M.TORKHANI
   2
   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.
  10 #
  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.
  15 #
  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
  21
  22
  23
  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
  30
  31     import numpy
  32     from math import pi
  33     import aster
  34     from Accas import _F
  35     from Noyau.N_types import is_float
  36
  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
  41     )
  42
  43
  44     # On importe les definitions des commandes a utiliser dans la macro
  45
  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')
  59
  60
  61     # La macro compte pour 1 dans la numerotation des commandes
  62     self.set_icmd(1)
  63
  64
  65     lvit=[None]
  66     # Extraire les vitesses de rotation
  67     nb_temp=0
  68     while 1 :
  69         try:
  70             print 'nb_temp', nb_temp
  71             lvit[nb_temp]         = MODES['VITE_ROTA' ,nb_temp+1];
  72             nb_temp=nb_temp+1;
  73             lvit.append([None]);
  74         except KeyError:
  75             break
  76
  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
  80     nbV1=len(VITE_ROTA);
  81     lmo=[None]*nbV1
  82     for ii in range(0,nbV1):
  83         itri = num_vit_tri[ii];
  84         lmo[ii]=EXTR_TABLE(TYPE_RESU='MODE_MECA',
  85                        TABLE=MODES,
  86                        NOM_PARA='NOM_SD',
  87                        FILTRE=_F(NOM_PARA='NUME_VITE',VALE_I=itri),);
  88
  89     L_VIT1=[];
  90
  91     if type(VITE_ROTA)==list:
  92         L_VIT1=VITE_ROTA;
  93     elif type(VITE_ROTA)==tuple:
  94         L_VIT1=list(VITE_ROTA);
  95     elif is_float(VITE_ROTA):
  96         L_VIT1.append(VITE_ROTA);
  97
  98
  99     nbV=len(L_VIT1);
 100
 101     chaine='\n'
 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)
 108
 109
 110     #-------------------------------------------------------------------------
 111     # Tester le nombre de frequences calculees pour chaque vitesse de rotation
 112     #-------------------------------------------------------------------------
 113
 114     nb_FREQ=[];
 115     for ii in range(nbV):
 116         # frequences totales
 117         tabfreq = RECU_TABLE(CO= lmo[ii],NOM_PARA='FREQ',);
 118         tab2=tabfreq.EXTR_TABLE();
 119         tabf=tab2.FREQ;
 120         nb_FREQ_prec=nb_FREQ;
 121         nb_FREQ.append(len(tabf));
 122
 123         DETRUIRE(CONCEPT=_F(NOM=(tabfreq)),INFO=1)
 124
 125     nbf_max=max(nb_FREQ);
 126     nbf_min=min(nb_FREQ);
 127     NFREQ =nbf_min;
 128     if nbf_max!=nbf_min:
 129          chaine='\n'
 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)
 135     else:
 136         chaine='\n'
 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)
 146     else:
 147            chaine='Nombre de frequences demandees pour le trace  %d' %NFREQ_CAMP
 148            aster.affiche('RESULTAT', chaine)
 149     if NFREQ_CAMP <=0 :
 150         chaine='Le trace du diagramme de Campbell s''arrete !.'
 151         aster.affiche('RESULTAT', chaine)
 152
 153
 154     if NFREQ_CAMP>0:
 155
 156 # ------------------------------------------------------------------
 157 # Classe les modes en flexion, en torsion , en traction/ compression
 158 # ------------------------------------------------------------------
 159         Mf=[];
 160         Mt=[];
 161         Ml=[];
 162
 163
 164         # Recuperer les noeuds du maillage
 165         # construction des vecteurs jeveux
 166         nom_mail=MAILLAGE.nom
 167         lenm=len(nom_mail)
 168         nom_mail=nom_mail+' '*(8-lenm)
 169         vectnoeu=nom_mail+'.NOMNOE'
 170         L_GR_NOEUD=aster.getvectjev(vectnoeu)
 171
 172
 173         NOEU=len(L_GR_NOEUD);
 174         C_MODES=CLASS_MODES(self,lmo,NFREQ,NFREQ_CAMP,L_GR_NOEUD,L_VIT1);
 175
 176         NFREQ_f=C_MODES[0];
 177         NFREQ_t=C_MODES[1];
 178         NFREQ_l=C_MODES[2];
 179         Mf=C_MODES[3];
 180         Mt=C_MODES[4];
 181         Ml=C_MODES[5];
 182
 183         # Initialisation des tableaux de connexion apres classement
 184         # en gardant la numerotation globale des modes
 185         NVT=C_MODES[6];
 186         NVTf_int=C_MODES[7];
 187         NVTt_int=C_MODES[8];
 188         NVTl_int=C_MODES[9];
 189         NFREQ_fc=C_MODES[10];
 190         NFREQ_tc=C_MODES[11];
 191         NFREQ_lc=C_MODES[12];
 192
 193         chaine='\n'
 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)
 203
 204         chaine='\n'
 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);
 211         if NFREQ_f>0:
 212             chaine='Modes de flexion'
 213             aster.affiche('RESULTAT', chaine)
 214             affiche_tabint(NVTf_int,NFREQ_f, nbV);
 215         if NFREQ_t>0:
 216             chaine='Modes de torsion'
 217             aster.affiche('RESULTAT', chaine)
 218             affiche_tabint(NVTt_int,NFREQ_t, nbV);
 219         if NFREQ_l>0:
 220             chaine='Modes de traction/compression'
 221             aster.affiche('RESULTAT', chaine)
 222             affiche_tabint(NVTl_int,NFREQ_l, nbV);
 223
 224     #-----------------------
 225     #Extraire les frequences
 226     #-----------------------
 227         FREQ=EXTR_FREQ(self,lmo,Mf,Mt,Ml, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l);
 228         FRQ=FREQ[0]
 229         FRQf=FREQ[1]
 230         FRQt=FREQ[2]
 231         FRQl=FREQ[3]
 232         FRQ_max=FREQ[4]
 233         AMOf=FREQ[5]
 234
 235         chaine='\n'
 236         aster.affiche('RESULTAT', chaine)
 237         chaine='Frequences totales'
 238         aster.affiche('RESULTAT', chaine)
 239         affiche_tab(FRQ,NFREQ, nbV);
 240         if NFREQ_f>0:
 241             chaine='\n'
 242             aster.affiche('RESULTAT', chaine)
 243             chaine='Frequences en flexion'
 244             aster.affiche('RESULTAT', chaine)
 245             affiche_tab(FRQf,NFREQ_f, nbV);
 246             chaine='\n'
 247             aster.affiche('RESULTAT', chaine)
 248             chaine='Amortissement reduit'
 249             aster.affiche('RESULTAT', chaine)
 250             affiche_tab(AMOf,NFREQ_f, nbV);
 251             chaine='\n'
 252             aster.affiche('RESULTAT', chaine)
 253         if NFREQ_t>0:
 254             chaine='Frequences en torsion'
 255             aster.affiche('RESULTAT', chaine)
 256             affiche_tab(FRQt,NFREQ_t, nbV);
 257             chaine='\n'
 258             aster.affiche('RESULTAT', chaine)
 259         if NFREQ_l>0:
 260             chaine='Frequences en traction/compression'
 261             aster.affiche('RESULTAT', chaine)
 262             affiche_tab(FRQl,NFREQ_l, nbV);
 263
 264     # Initialisation des tableaux de connexion
 265     # nouveau numerotation de modes par type de mode
 266     # Sans tri
 267         if NFREQ_f>0 :
 268             NVTf =numpy.zeros((NFREQ_f, nbV), int);
 269             for ii in range(nbV):
 270                 for jj in range(NFREQ_f):
 271                     NVTf[jj][ii]=jj+1;
 272             chaine='\n'
 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);
 277
 278         if NFREQ_t>0 :
 279             NVTt =numpy.zeros((NFREQ_t, nbV), int);
 280             for ii in range(nbV):
 281                 for jj in range(NFREQ_t):
 282                     NVTt[jj][ii]=jj+1;
 283             chaine='\n'
 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);
 288
 289         if NFREQ_l>0 :
 290             NVTl =numpy.zeros((NFREQ_l, nbV), int);
 291             for ii in range(nbV):
 292                 for jj in range(NFREQ_l):
 293                     NVTl[jj][ii]=jj+1;
 294             chaine='\n'
 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);
 299
 300     # ------------------------------------------------------------------
 301     # Tri par forme des modes
 302     # Tri des frequences par calcul des coefficients MAC
 303     # Remplissage du tableau de connexion
 304     # ------------------------------------------------------------------
 305         if TYP_TRI==2 :
 306             # ------------------------------------------------------------------
 307             # Calcul de la matrice MAC entre les bases successives en flexion
 308             # ------------------------------------------------------------------
 309             if NFREQ_f>0:
 310                 LMACf=CALC_MACf(self, Mf, NFREQ_f) ;
 311                 chaine='\n'
 312                 aster.affiche('RESULTAT', chaine)
 313                 chaine=' Tri par forme des modes TRI_FORM_MOD'
 314                 aster.affiche('RESULTAT', chaine)
 315
 316                 for ii in range(nbV-1):
 317                     chaine='\n'
 318                     aster.affiche('RESULTAT', chaine)
 319                     iv=nbV-ii-2
 320                     NVTf_mac=TRI_MODE_MACf(self, LMACf[iv],NFREQ_f, NVTf, iv);
 321
 322                 OMIN = L_VIT1[0];
 323                 if(OMIN==0) :
 324                     for ii in range(NFREQ_f):
 325                         NVTf_mac[ii][0]=NVTf_mac[ii][1] ;
 326
 327                 chaine='\n'
 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);
 332
 333             # ------------------------------------------------------------------
 334             # Calcul de la matrice MAC entre les bases successives en torsion
 335             # ------------------------------------------------------------------
 336             if NFREQ_t>0:
 337                 LMACt=CALC_MACt(self, Mt, NFREQ_t) ;
 338
 339                 for ii in range(nbV-1):
 340                     chaine='\n'
 341                     aster.affiche('RESULTAT', chaine)
 342                     iv=nbV-ii-2
 343                     NVTt=TRI_MODE_MACt(self, LMACt[iv],NFREQ_t, NVTt, iv);
 344                 chaine='\n'
 345                 aster.affiche('RESULTAT', chaine)
 346                 chaine='Tableau de connexion en torsion'
 347                 aster.affiche('RESULTAT', chaine)
 348                 affiche_tabint(NVTt,NFREQ_t, nbV);
 349
 350             # ----------------------------------------------------------------------------
 351             # Calcul de la matrice MAC entre les bases successives en traction/compression
 352             # ----------------------------------------------------------------------------
 353             if NFREQ_l>0:
 354                 LMACl=CALC_MACl(self, Ml, NFREQ_l) ;
 355
 356                 for ii in range(nbV-1):
 357                     chaine='\n'
 358                     aster.affiche('RESULTAT', chaine)
 359                     iv=nbV-ii-2
 360                     NVTl=TRI_MODE_MACl(self, LMACl[iv],NFREQ_l, NVTl, iv);
 361                 chaine='\n'
 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);
 366
 367
 368         #--------------------------------------------------------------------------
 369         # Calcul le sens de precession pour les modes en flexion a une vitesse de rotation donnee
 370         #--------------------------------------------------------------------------
 371         if NFREQ_f>0:
 372             SENS=CALC_PREC(self, Mf,NFREQ_f,L_GR_NOEUD, TYP_PREC);
 373
 374             chaine='\n'
 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);
 379
 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         # ------------------------------------------------------------------
 385         if TYP_TRI==1 :
 386             if NFREQ_f>0:
 387                 OMIN = L_VIT1[0]
 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];
 392
 393
 394
 395         # --------------------------------
 396         # Trace du diagramme de campbell
 397         # --------------------------------
 398         chaine='Trace du diagramme de campbell'
 399         aster.affiche('RESULTAT', chaine)
 400
 401         #Conversion de la vitesse de rotation en tr/mn pour l'affichage
 402         OM = L_VIT1;
 403         for ii in range(nbV):
 404             OM[ii] = OM[ii]*30./pi;
 405
 406         Vitesse_min = min(OM);
 407         Vitesse_max = max(OM);
 408
 409         OM_int=[OM[ii] for ii in range(len(OM))]; # pour le calcul des points d'intersection
 410
 411         legende_x= 'Vitesse (tr/mn)';
 412         if  Vitesse_min<0:
 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]);
 417
 418         __FX=DEFI_LIST_REEL(VALE=OM);
 419
 420         # Mise en page graphique
 421         Vmin=min(OM);
 422         Vmax=max(OM);
 423
 424
 425
 426         # Determination de la frequence maximale
 427         Fmax=0.0;
 428         for jf in range(NFREQ_fc):
 429             for iv in range(nbV):
 430                 if TYP_TRI==0:
 431                     jf1=NVTf[jf][iv]-1;
 432                 if TYP_TRI==1:
 433                     jf1=NVTf_prec[jf][iv]-1;
 434                 if TYP_TRI==2:
 435                     jf1=NVTf_mac[jf][iv]-1;
 436                 F1=FRQf[jf1][iv];
 437                 if Fmax<F1:
 438                     Fmax=F1;
 439
 440         for jf in range(NFREQ_tc):
 441             for iv in range(nbV):
 442                 jf1=NVTt[jf][iv]-1;
 443                 F1=FRQt[jf1][iv];
 444                 if Fmax<F1:
 445                     Fmax=F1;
 446
 447         for jf in range(NFREQ_lc):
 448             for iv in range(nbV):
 449                 jf1=NVTl[jf][iv]-1;
 450                 F1=FRQl[jf1][iv];
 451                 if Fmax<F1:
 452                     Fmax=F1;
 453
 454         Fmin=0.0;
 455         Fmax=Fmax*1.1;
 456
 457         # Calcul des bornes et pas de la grille pour les vitesses de rotation
 458         BV    = calc_pas(Vmin, Vmax);
 459         BVmin = BV[0];
 460         BVmax = BV[1];
 461         pasV  = BV[2];
 462
 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);
 466         BFmin = BF[0];
 467         BFmax = BF[1];
 468         pasF  = BF[2];
 469
 470         chaine='\n'
 471         aster.affiche('RESULTAT', chaine)
 472         chaine='Fmax ' + str(Fmax) + ' BFmax ' + str(BFmax)
 473         aster.affiche('RESULTAT', chaine)
 474
 475         TITRE1 = 'Diagramme de Campbell';
 476         TITRE2 = 'Modes en flexion'
 477
 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         # ---------------------------------------------------
 485         EPSI=1.E-7
 486         LFONC =[];
 487         FON1  =[];
 488         mfac1 ={};
 489         ll    =0;
 490         if NFREQ_fc>0:
 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
 495                     if TYP_TRI==0:
 496                         jf1=NVTf[jf][iv]-1;
 497                         jf2=NVTf[jf][iv+1]-1;
 498                     if TYP_TRI==1:
 499                         jf1=NVTf_prec[jf][iv]-1;
 500                         jf2=NVTf_prec[jf][iv+1]-1;
 501                     if TYP_TRI==2:
 502                         jf1=NVTf_mac[jf][iv]-1;
 503                         jf2=NVTf_mac[jf][iv+1]-1;
 504
 505                     # Frequences
 506                     if jf1>=0 and jf2>=0:
 507                         F1=FRQf[jf1][iv];
 508                         F2=FRQf[jf2][iv+1];
 509                         A1=AMOf[jf1][iv];
 510                         A2=AMOf[jf2][iv+1];
 511
 512                         # Vitesses
 513                         OM1=OM[iv];
 514                         OM2=OM[iv+1];
 515                         S1=SENS[jf1][iv];
 516                         S2=SENS[jf2][iv+1];
 517
 518                         if OM1==0.0 :
 519                             S1=S2;
 520                         if S1*S2<0 :  # Changement de precession
 521                             OM3=(OM1+OM2)/2;
 522                             F3 =(F1+F2)/2;
 523
 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)
 529                             F4 = aa* OM4 + bb
 530
 531                         # OM4 en dehors de OM1, OM2
 532                         if OM4 >=OM2:
 533                             OM4=-1;
 534
 535                         if OM4 <=OM1:
 536                             OM4=-1;
 537
 538                         if (A1 <0) and (abs(A1) < A0):
 539                             A1 = 0.0
 540                         if (A2 <0) and (abs(A2) < A0):
 541                             A2 = 0.0
 542
 543                         # Tracer le segment pour chaque intervalle avec le code de couleur et
 544                         # de style adequats
 545
 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);
 551                             ICS2=CS2[0];
 552                             IST2=CS2[1];
 553                             IMA2=CS2[2];
 554
 555                             FON1.append([]);
 556                             ll=len(FON1)-1;
 557                             FON1[ll]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
 558
 559                             DICO={};
 560                             DICO["FONCTION"]=FON1[ll];
 561                             DICO["COULEUR"] =ICS2;
 562                             DICO["STYLE"]   =IST2;
 563                             DICO["MARQUEUR"]=IMA2;
 564                             DICO["LEGENDE"] ='';
 565                             LFONC.append(DICO);
 566
 567                             DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1)),INFO=1);
 568
 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);
 576                             ICS1=CS1[0];
 577                             IST1=CS1[1];
 578                             IMA1=CS1[2];
 579                             CS2=color_camp(S2,A1);
 580                             ICS2=CS2[0];
 581                             IST2=CS2[1];
 582                             IMA2=CS2[2];
 583
 584                             FON1.append([]);
 585                             ll=len(FON1)-1;
 586                             FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
 587
 588                             DICO={};
 589                             DICO["FONCTION"]=FON1[ll];
 590                             DICO["COULEUR"] =ICS1;
 591                             DICO["STYLE"]   =IST1;
 592                             DICO["MARQUEUR"]=IMA1;
 593                             DICO["LEGENDE"] ='';
 594                             LFONC.append(DICO);
 595
 596                             FON1.append([]);
 597                             ll=len(FON1)-1;
 598                             FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
 599
 600                             DICO={};
 601                             DICO["FONCTION"]=FON1[ll];
 602                             DICO["COULEUR"] =ICS2;
 603                             DICO["STYLE"]   =IST2;
 604                             DICO["MARQUEUR"]=IMA2;
 605                             DICO["LEGENDE"] ='';
 606                             LFONC.append(DICO);
 607
 608                             DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2)),INFO=1);
 609
 610                         # 3 cas, de changement de stabilite
 611                         elif (OM3 == -1) and (OM4 >= 0):
 612
 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);
 618                             ICS1=CS1[0];
 619                             IST1=CS1[1];
 620                             IMA1=CS1[2];
 621                             CS2=color_camp(S2,A2);
 622                             ICS2=CS2[0];
 623                             IST2=CS2[1];
 624                             IMA2=CS2[2];
 625
 626                             FON1.append([]);
 627                             ll=len(FON1)-1;
 628                             FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
 629
 630                             DICO={};
 631                             DICO["FONCTION"]=FON1[ll];
 632                             DICO["COULEUR"] =ICS1;
 633                             DICO["STYLE"]   =IST1;
 634                             DICO["MARQUEUR"]=IMA1;
 635                             DICO["LEGENDE"] ='';
 636                             LFONC.append(DICO);
 637
 638                             FON1.append([]);
 639                             ll=len(FON1)-1;
 640                             FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
 641
 642                             DICO={};
 643                             DICO["FONCTION"]=FON1[ll];
 644                             DICO["COULEUR"] =ICS2;
 645                             DICO["STYLE"]   =IST2;
 646                             DICO["MARQUEUR"]=IMA2;
 647                             DICO["LEGENDE"] ='';
 648                             LFONC.append(DICO);
 649
 650                             DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2)),INFO=1);
 651
 652                         # 4 et 5 cas de changement de sens de precession et de stabilite
 653                         elif (OM3 >= 0) and (OM4 >= 0):
 654                             # 4 eme cas
 655                             if (OM4 < OM3):
 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);
 663                                 ICS1=CS1[0];
 664                                 IST1=CS1[1];
 665                                 IMA1=CS1[2];
 666                                 CS2=color_camp(S1,A2);
 667                                 ICS2=CS2[0];
 668                                 IST2=CS2[1];
 669                                 IMA2=CS2[2];
 670                                 CS3=color_camp(S2,A2);
 671                                 ICS3=CS3[0];
 672                                 IST3=CS3[1];
 673                                 IMA3=CS3[2];
 674
 675                                 FON1.append([]);
 676                                 ll=len(FON1)-1;
 677                                 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
 678
 679                                 DICO={};
 680                                 DICO["FONCTION"]=FON1[ll];
 681                                 DICO["COULEUR"] =ICS1;
 682                                 DICO["STYLE"]   =IST1;
 683                                 DICO["MARQUEUR"]=IMA1;
 684                                 DICO["LEGENDE"] ='';
 685                                 LFONC.append(DICO);
 686
 687                                 FON1.append([]);
 688                                 ll=len(FON1)-1;
 689                                 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
 690
 691                                 DICO={};
 692                                 DICO["FONCTION"]=FON1[ll];
 693                                 DICO["COULEUR"] =ICS2;
 694                                 DICO["STYLE"]   =IST2;
 695                                 DICO["MARQUEUR"]=IMA2;
 696                                 DICO["LEGENDE"] ='';
 697                                 LFONC.append(DICO);
 698
 699                                 FON1.append([]);
 700                                 ll=len(FON1)-1;
 701                                 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX3,VALE_FONC=FY3);
 702
 703                                 DICO={};
 704                                 DICO["FONCTION"]=FON1[ll];
 705                                 DICO["COULEUR"] =ICS3;
 706                                 DICO["STYLE"]   =IST3;
 707                                 DICO["MARQUEUR"]=IMA3;
 708                                 DICO["LEGENDE"] ='';
 709                                 LFONC.append(DICO);
 710
 711                                 DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2, FX3,FY3)),INFO=1);
 712
 713                             # 5 eme cas
 714                             else:
 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);
 722                                 ICS1=CS1[0];
 723                                 IST1=CS1[1];
 724                                 IMA1=CS1[2];
 725                                 CS2=color_camp(S2,A1);
 726                                 ICS2=CS2[0];
 727                                 IST2=CS2[1];
 728                                 IMA2=CS2[2];
 729                                 CS3=color_camp(S2,A2);
 730                                 ICS3=CS3[0];
 731                                 IST3=CS3[1];
 732                                 IMA3=CS3[2];
 733
 734                                 FON1.append([]);
 735                                 ll=len(FON1)-1;
 736                                 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
 737
 738                                 DICO={};
 739                                 DICO["FONCTION"]=FON1[ll];
 740                                 DICO["COULEUR"] =ICS1;
 741                                 DICO["STYLE"]   =IST1;
 742                                 DICO["MARQUEUR"]=IMA1;
 743                                 DICO["LEGENDE"] ='';
 744                                 LFONC.append(DICO);
 745
 746                                 FON1.append([]);
 747                                 ll=len(FON1)-1;
 748                                 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
 749
 750                                 DICO={};
 751                                 DICO["FONCTION"]=FON1[ll];
 752                                 DICO["COULEUR"] =ICS2;
 753                                 DICO["STYLE"]   =IST2;
 754                                 DICO["MARQUEUR"]=IMA2;
 755                                 DICO["LEGENDE"] ='';
 756                                 LFONC.append(DICO);
 757
 758                                 FON1.append([]);
 759                                 ll=len(FON1)-1;
 760                                 FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX3,VALE_FONC=FY3);
 761                                 DICO={};
 762                                 DICO["FONCTION"]=FON1[ll];
 763                                 DICO["COULEUR"] =ICS3;
 764                                 DICO["STYLE"]   =IST3;
 765                                 DICO["MARQUEUR"]=IMA3;
 766                                 DICO["LEGENDE"] ='';
 767                                 LFONC.append(DICO);
 768
 769                                 DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2, FX3, FY3)),INFO=1);
 770
 771
 772
 773             mfac1["COURBE"]=LFONC;
 774
 775             IMPR_FONCTION(
 776                         UNITE   = UNIT_FLE,
 777                         FORMAT  = 'XMGRACE',
 778                         BORNE_X = (BVmin,BVmax),
 779                         BORNE_Y = (BFmin,BFmax),
 780                         TITRE   = TITRE1,
 781                         SOUS_TITRE   = TITRE2,
 782                         GRILLE_X = pasV,
 783                         GRILLE_Y = pasF,
 784                         LEGENDE_X = legende_x,
 785                         LEGENDE_Y = 'FREQ (Hz)',
 786                             **mfac1);
 787
 788             IMPR_FONCTION(
 789                         UNITE   = UNIT_TOT,
 790                         FORMAT  = 'XMGRACE',
 791                         BORNE_X = (BVmin,BVmax),
 792                         BORNE_Y = (BFmin,BFmax),
 793                         TITRE   = TITRE1,
 794                         SOUS_TITRE   = TITRE2,
 795                         GRILLE_X = pasV,
 796                         GRILLE_Y = pasF,
 797                         LEGENDE_X = legende_x,
 798                         LEGENDE_Y = 'FREQ (Hz)',
 799                             **mfac1);
 800             nbll = len(FON1)
 801             for ii in range(nbll):
 802                 DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
 803             del(LFONC)
 804             del(mfac1, DICO)
 805
 806
 807
 808         # ---------------------------------------------------
 809         # Trace du diagramme de campbell des modes en torsion
 810         # ---------------------------------------------------
 811         TITRE2 = 'Modes en Torsion'
 812         if NFREQ_tc>0:
 813             LFONC =[];
 814             FON1 =[0]*NFREQ_tc;
 815             mfac1={};
 816             for jj in range(NFREQ_tc):
 817
 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);
 820
 821
 822                DICO={};
 823                DICO["FONCTION"]=FON1[jj];
 824                DICO["COULEUR"] =1;
 825                DICO["STYLE"]   =6;
 826                DICO["MARQUEUR"]=0;
 827                DICO["LEGENDE"] ='';
 828                LFONC.append(DICO);
 829
 830                DETRUIRE(CONCEPT=_F(NOM=(FY1)),INFO=1);
 831
 832             mfac1["COURBE"]=LFONC;
 833             IMPR_FONCTION(
 834                   UNITE    = UNIT_TOR,
 835                   FORMAT   ='XMGRACE',
 836                   BORNE_X  =(BVmin,BVmax),
 837                   BORNE_Y  =(BFmin,BFmax),
 838                   TITRE   = TITRE1,
 839                   SOUS_TITRE = TITRE2,
 840                   GRILLE_X = pasV,
 841                   GRILLE_Y = pasF,
 842                   LEGENDE_X = legende_x,
 843                   LEGENDE_Y = 'FREQ (Hz)',
 844                   **mfac1);
 845
 846             IMPR_FONCTION(
 847                   UNITE    = UNIT_TOT,
 848                   FORMAT   ='XMGRACE',
 849                   BORNE_X  =(BVmin,BVmax),
 850                   BORNE_Y  =(BFmin,BFmax),
 851                   TITRE   = TITRE1,
 852                   GRILLE_X = pasV,
 853                   GRILLE_Y = pasF,
 854                   LEGENDE_X = legende_x,
 855                   LEGENDE_Y = 'FREQ (Hz)',
 856                   **mfac1);
 857
 858
 859
 860             for ii in range(NFREQ_tc):
 861                 DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
 862             del(LFONC)
 863             del(mfac1, DICO)
 864
 865
 866         # ----------------------------------------------------------------
 867         # Trace du diagramme de campbell des modes en traction/compression
 868         # ----------------------------------------------------------------
 869         TITRE2 = 'Modes en traction/compression'
 870         if NFREQ_lc>0:
 871             LFONC =[];
 872             FON1 =[0]*NFREQ_lc;
 873             mfac1={};
 874             for jj in range(NFREQ_lc):
 875
 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);
 878
 879                 DICO={};
 880                 DICO["FONCTION"]=FON1[jj];
 881                 DICO["COULEUR"] =8;
 882                 DICO["STYLE"]   =8;
 883                 DICO["MARQUEUR"]=0;
 884                 DICO["LEGENDE"] ='';
 885                 LFONC.append(DICO);
 886
 887                 DETRUIRE(CONCEPT=_F(NOM=(FY1)),INFO=1);
 888
 889             mfac1["COURBE"]=LFONC;
 890             IMPR_FONCTION(
 891                   UNITE    = UNIT_LON,
 892                   FORMAT   ='XMGRACE',
 893                   BORNE_X  =(BVmin,BVmax),
 894                   BORNE_Y  =(BFmin,BFmax),
 895                   TITRE   = TITRE1,
 896                   SOUS_TITRE = TITRE2,
 897                   GRILLE_X = pasV,
 898                   GRILLE_Y = pasF,
 899                   LEGENDE_X = legende_x,
 900                   LEGENDE_Y = 'FREQ (Hz)',
 901                       **mfac1);
 902             IMPR_FONCTION(
 903                   UNITE    = UNIT_TOT,
 904                   FORMAT   ='XMGRACE',
 905                   BORNE_X  =(BVmin,BVmax),
 906                   BORNE_Y  =(BFmin,BFmax),
 907                   TITRE   = TITRE1,
 908                   GRILLE_X = pasV,
 909                   GRILLE_Y = pasF,
 910                   LEGENDE_X = legende_x,
 911                   LEGENDE_Y = 'FREQ (Hz)',
 912                       **mfac1);
 913
 914
 915
 916             for ii in range(NFREQ_lc):
 917                 DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
 918             del(LFONC)
 919             del(mfac1, DICO);
 920
 921         if NFREQ_f>0:
 922             for jj in range(nbV):
 923                 DETRUIRE(CONCEPT=_F(NOM=(Mf[jj])),INFO=1)
 924         if NFREQ_t>0:
 925             for jj in range(nbV):
 926                 DETRUIRE(CONCEPT=_F(NOM=(Mt[jj])),INFO=1)
 927         if NFREQ_l>0:
 928             for jj in range(nbV):
 929                 DETRUIRE(CONCEPT=_F(NOM=(Ml[jj])),INFO=1)
 930
 931
 932
 933 #------------------------------------------------------------------------------------
 934
 935         # -----------------------------
 936         # Trace des droites de pentes S
 937         # -----------------------------
 938
 939         # Pour S=1, on le trace automatiquement
 940         S=1.0;
 941         L_S1=[];
 942
 943         if type(L_S)==list:
 944             L_S1=L_S;
 945         elif type(L_S)==tuple:
 946             L_S1=list(L_S);
 947         elif is_float(L_S):
 948             L_S1.append(L_S);
 949         L_S1.append(S);
 950
 951         # Supprimer la redondance dans la liste
 952         sup_redon_list(L_S1);
 953
 954
 955         # Faire une dictionnaire de courbe
 956         # Constituer de liste de dictionnaire de fonctions
 957         LFONC =[];
 958         FON1 =[0]*len(L_S1);
 959         mfac1={};
 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]);
 965
 966             FON1[ii]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
 967
 968             DICO={};
 969             DICO["FONCTION"]=FON1[ii];
 970             DICO["COULEUR"] =1;
 971             DICO["STYLE"]   =1;
 972             DICO["MARQUEUR"]=0;
 973             DICO["LEGENDE"] ='';
 974             LFONC.append(DICO);
 975
 976             DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1)),INFO=1);
 977
 978         mfac1["COURBE"]=LFONC;
 979         if NFREQ_fc>0:
 980             TITRE2 = 'Modes en flexion'
 981             IMPR_FONCTION(
 982                         UNITE   = UNIT_FLE,
 983                         FORMAT  = 'XMGRACE',
 984                         BORNE_X = (BVmin,BVmax),
 985                         BORNE_Y = (BFmin,BFmax),
 986                         TITRE   = TITRE1,
 987                         SOUS_TITRE   = TITRE2,
 988                         GRILLE_X = pasV,
 989                         GRILLE_Y = pasF,
 990                         LEGENDE_X = legende_x,
 991                         LEGENDE_Y = 'FREQ (Hz)',
 992                         **mfac1);
 993
 994         if NFREQ_tc>0:
 995             TITRE2 = 'Modes en Torsion'
 996             IMPR_FONCTION(
 997                         UNITE   = UNIT_TOR,
 998                         FORMAT  = 'XMGRACE',
 999                         BORNE_X = (BVmin,BVmax),
1000                         BORNE_Y = (BFmin,BFmax),
1001                         TITRE   = TITRE1,
1002                         SOUS_TITRE   = TITRE2,
1003                         GRILLE_X = pasV,
1004                         GRILLE_Y = pasF,
1005                         LEGENDE_X = legende_x,
1006                         LEGENDE_Y = 'FREQ (Hz)',
1007                             **mfac1);
1008         if NFREQ_lc>0:
1009             TITRE2 = 'Modes en traction/compression'
1010             IMPR_FONCTION(
1011                         UNITE   = UNIT_LON,
1012                         FORMAT  = 'XMGRACE',
1013                         BORNE_X = (BVmin,BVmax),
1014                         BORNE_Y = (BFmin,BFmax),
1015                         TITRE   = TITRE1,
1016                         SOUS_TITRE   = TITRE2,
1017                         GRILLE_X = pasV,
1018                         GRILLE_Y = pasF,
1019                         LEGENDE_X = legende_x,
1020                         LEGENDE_Y = 'FREQ (Hz)',
1021                             **mfac1);
1022
1023         IMPR_FONCTION(
1024                         UNITE   = UNIT_TOT,
1025                         FORMAT  = 'XMGRACE',
1026                         BORNE_X = (BVmin,BVmax),
1027                         BORNE_Y = (BFmin,BFmax),
1028                         TITRE   = TITRE1,
1029                         GRILLE_X = pasV,
1030                         GRILLE_Y = pasF,
1031                         LEGENDE_X = legende_x,
1032                         LEGENDE_Y = 'FREQ (Hz)',
1033                             **mfac1);
1034
1035         for ii in range(len(L_S1)):
1036             DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
1037
1038         del(LFONC)
1039         del(mfac1, DICO)
1040
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,)
1045
1046 #------------------------------------------------------------------------------------
1047
1048         # --------------------------------------------------------------
1049         # Determination des points d'intersection avec les droites Y=AX
1050         # Calcul des coordonnees des points
1051         # --------------------------------------------------------------
1052
1053
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')
1058
1059         INTERSEC =[];
1060         # Modes en flexion
1061
1062         for ii in range(len(L_S1)):
1063             DICO={};
1064             DICO["pente"]=L_S1[ii];
1065             ll=0;
1066             XY=[[None]*2];
1067             for jf in range(NFREQ_fc):
1068                 for iv in range(nbV-1):
1069                     if TYP_TRI==0:
1070                         jf1=NVTf[jf][iv]-1;
1071                         jf2=NVTf[jf][iv+1]-1;
1072                     if TYP_TRI==1:
1073                         jf1=NVTf_prec[jf][iv]-1;
1074                         jf2=NVTf_prec[jf][iv+1]-1;
1075                     if TYP_TRI==2:
1076                         jf1=NVTf_mac[jf][iv]-1;
1077                         jf2=NVTf_mac[jf][iv+1]-1;
1078                     if jf1>=0 and jf2>=0:
1079                         X1 = OM[iv];
1080                         Y1 = FRQf[jf1][iv];
1081                         X2 = OM[iv+1];
1082                         Y2 = FRQf[jf2][iv+1];
1083                         A  = (Y1-Y2)/(X1-X2);
1084                         B  = Y1-(A*X1);
1085                         pente = L_S1[ii];
1086                         P1 = B*60./(pente-A*60.);
1087                         P2 = P1*pente/60.;
1088
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
1092                                     P1=-P1;
1093                                 XY[ll][0]=P1;
1094                                 XY[ll][1]=P2;
1095                                 # On ajoute une ligne supplementaire
1096                                 XY.append([None]*2);
1097                                 ll=ll+1;
1098
1099
1100             L_XY=XY[0:ll];
1101             DICO["point"]=L_XY;
1102             INTERSEC.append(DICO);
1103
1104         # Sauvegarde des points d'intersection
1105         FINT1.write('\n')
1106         chaine = 'Mode en flexion'
1107         FINT1.write(chaine)
1108         save_intersec(INTERSEC, FINT1);
1109
1110         del(XY, L_XY)
1111         del(INTERSEC, DICO)
1112
1113         INTERSEC =[];
1114         # Modes en torsion
1115         for ii in range(len(L_S1)):
1116             DICO={};
1117             DICO["pente"]=L_S1[ii];
1118             ll=0;
1119             XY=[[None]*2];
1120             for jf in range(NFREQ_tc):
1121                 for iv in range(nbV-1):
1122                     jf1=NVTt[jf][iv]-1;
1123                     jf2=NVTt[jf][iv+1]-1;
1124                     if jf1>=0 and jf2>=0:
1125                         X1 = OM[iv];
1126                         Y1 = FRQt[jf1][iv];
1127                         X2 = OM[iv+1];
1128                         Y2 = FRQt[jf2][iv+1];
1129                         A  = (Y1-Y2)/(X1-X2);
1130                         B  = Y1-(A*X1);
1131                         pente = L_S1[ii];
1132                         P1 = B*60./(pente-A*60.);
1133                         P2 = P1*pente/60.;
1134
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
1138                                     P1=-P1;
1139                                 XY[ll][0]=P1;
1140                                 XY[ll][1]=P2;
1141                                 # On ajoute une ligne supplementaire
1142                                 XY.append([None]*2);
1143                                 ll=ll+1;
1144
1145             L_XY=XY[0:ll];
1146             DICO["point"]=L_XY;
1147             INTERSEC.append(DICO);
1148
1149         # Sauvegarde des points d'intersection
1150         FINT1.write('\n')
1151         FINT1.write('\n')
1152         chaine = 'Mode en Torsion'
1153         FINT1.write(chaine)
1154         save_intersec(INTERSEC, FINT1);
1155
1156         del(XY, L_XY)
1157         del(INTERSEC, DICO)
1158
1159
1160 #------------------------------------------------------------------------------------
1161
1162         INTERSEC =[];
1163         # Modes en traction / compression
1164         for ii in range(len(L_S1)):
1165             DICO={};
1166             DICO["pente"]=L_S1[ii];
1167             ll=0;
1168             XY=[[None]*2];
1169             for jf in range(NFREQ_lc):
1170                 for iv in range(nbV-1):
1171                     jf1=NVTl[jf][iv]-1;
1172                     jf2=NVTl[jf][iv+1]-1;
1173                     if jf1>=0 and jf2>=0:
1174                         X1 = OM[iv];
1175                         Y1 = FRQl[jf1][iv];
1176                         X2 = OM[iv+1];
1177                         Y2 = FRQl[jf2][iv+1];
1178                         A  = (Y1-Y2)/(X1-X2);
1179                         B  = Y1-(A*X1);
1180                         pente = L_S1[ii];
1181                         P1 = B*60./(pente-A*60.);
1182                         P2 = P1*pente/60.;
1183
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
1187                                     P1=-P1;
1188                                 XY[ll][0]=P1;
1189                                 XY[ll][1]=P2;
1190                                 # On ajoute une ligne supplementaire
1191                                 XY.append([None]*2);
1192                                 ll=ll+1;
1193
1194             L_XY=XY[0:ll];
1195             DICO["point"]=L_XY;
1196             INTERSEC.append(DICO);
1197
1198         # Sauvegarde des points d'intersection
1199         FINT1.write('\n')
1200         FINT1.write('\n')
1201         chaine = 'Mode en traction / compression'
1202         FINT1.write(chaine)
1203         save_intersec(INTERSEC, FINT1);
1204
1205         del(XY, L_XY)
1206         del(INTERSEC, DICO)
1207         nbl=len(L_S1)
1208         for ii in range(nbl):
1209             il =nbl-ii-1;
1210             del L_S1[il];
1211         FINT1.close()
1212