Aster/Cata/cataSTA10/Macro/impr_diag_campbell_utils.py

   1 #@ MODIF impr_diag_campbell_utils Macro  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2010  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
  21 # RESPONSABLE TORKHANI M.TORKHANI
  22
  23 import numpy
  24 import aster
  25 from Accas import _F
  26
  27 # "self" est l'objet MACRO
  28
  29
  30 def CLASS_MODES(self,L_MODES, NFREQ, NFREQ_camp, L_GR_NOEUD, VITE_ROTA) :
  31     """Classification des modes en flexion, en torsion et en traction/compression"""
  32
  33     POST_RELEVE_T     =self.get_cmd('POST_RELEVE_T')
  34     EXTR_MODE         =self.get_cmd('EXTR_MODE')
  35     NORM_MODE         =self.get_cmd('NORM_MODE')
  36     DETRUIRE          =self.get_cmd('DETRUIRE')
  37     IMPR_TABLE        =self.get_cmd('IMPR_TABLE')
  38
  39     NFREQ_f=0;
  40     NFREQ_t=0;
  41     NFREQ_l=0;
  42
  43     nbF_f=[];
  44     nbF_t=[];
  45     nbF_l=[];
  46     lflex={};
  47     ltors={};
  48     llong={};
  49
  50     NBV=len(L_MODES);
  51
  52     Ntot =numpy.zeros((NFREQ));
  53     Nflex=numpy.zeros((NFREQ));
  54     Ntors=numpy.zeros((NFREQ));
  55     Nlong=numpy.zeros((NFREQ));
  56
  57     RESULT=[];
  58
  59     NBV=len(L_MODES);
  60     NOEU=len(L_GR_NOEUD);
  61     Mf=[0]*NBV ;
  62     Mt=[0]*NBV ;
  63     Ml=[0]*NBV ;
  64     NVT =numpy.zeros((NFREQ, NBV));
  65
  66     NVT_f=0
  67     NVT_l=0
  68     NVT_t=0
  69
  70     for ii in range(NBV):
  71         # -------------------------------------------------------------------
  72         # Extraire les modes en module, definir les differents types de modes
  73         # -------------------------------------------------------------------
  74
  75         tabmoN=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_MODULE',
  76                                 NOEUD=L_GR_NOEUD,
  77                                 RESULTAT=L_MODES[ii],
  78                                 NOM_CHAM='DEPL',
  79                                 TOUT_ORDRE='OUI',
  80                                 NOM_CMP=('DX','DY','DZ', 'DRX', 'DRY', 'DRZ'),
  81                                 FORMAT_C='MODULE',
  82                                 OPERATION='EXTRACTION',),);
  83         jj =0;
  84         for jj in range(NFREQ):
  85             Ntot[jj]  =0.0
  86             Nflex[jj] =0.0
  87             Ntors[jj] =0.0
  88             Nlong[jj] =0.0
  89             for ll in range(NOEU):
  90                 nmod=NOEU*jj+ll
  91                 dx  = tabmoN['DX' ,nmod+1]
  92                 dy  = tabmoN['DY' ,nmod+1]
  93                 dz  = tabmoN['DZ' ,nmod+1]
  94                 drx = tabmoN['DRX',nmod+1]
  95                 dry = tabmoN['DRY',nmod+1]
  96                 drz = tabmoN['DRZ',nmod+1]
  97                 Ntot1  = dx**2+dy**2+dz**2+drx**2+dry**2+drz**2
  98                 Nflex1 = dy**2+dz**2+dry**2+drz**2
  99                 Ntors1 = drx**2
 100                 Nlong1 = dx**2
 101                 Ntot[jj]  = Ntot[jj]  + Ntot1
 102                 Nflex[jj] = Nflex[jj] + Nflex1
 103                 Ntors[jj] = Ntors[jj] + Ntors1
 104                 Nlong[jj] = Nlong[jj] + Nlong1
 105
 106             Ntot[jj]  = numpy.sqrt(Ntot[jj])
 107             if  Ntot[jj] > 0:
 108                 Nflex[jj] = numpy.sqrt(Nflex[jj])/ Ntot[jj]
 109                 Ntors[jj] = numpy.sqrt(Ntors[jj])/ Ntot[jj]
 110                 Nlong[jj] = numpy.sqrt(Nlong[jj])/ Ntot[jj]
 111
 112
 113         DETRUIRE(CONCEPT=_F(NOM=(tabmoN)),INFO=1)
 114
 115         jf=0;
 116         jt=0;
 117         jl=0;
 118
 119         for jj in range(NFREQ):
 120             NVT[jj][ii]=jj+1;
 121             if (Nflex[jj]> Ntors[jj]) and (Nflex[jj]> Nlong[jj]):
 122                 lflex[(ii,jf)]=jj+1;
 123                 jf=jf+1;
 124
 125
 126             elif (Ntors[jj]> Nflex[jj]) and (Ntors[jj]> Nlong[jj]):
 127                 ltors[(ii,jt)]=jj+1;
 128                 jt=jt+1;
 129
 130
 131             elif (Nlong[jj]> Nflex[jj]) and (Nlong[jj]> Ntors[jj]):
 132                 llong[(ii,jl)]=jj+1;
 133                 jl=jl+1;
 134
 135         nbF_f.append(jf);
 136         nbF_t.append(jt);
 137         nbF_l.append(jl);
 138
 139     NFREQ_f = min(nbF_f)
 140     NFREQ_t = min(nbF_t)
 141     NFREQ_l = min(nbF_l)
 142
 143     if NFREQ_f>0:
 144         NVT_f =numpy.zeros((NFREQ_f, NBV), int);
 145         l_f   =numpy.zeros((NBV, NFREQ_f), int);
 146     if NFREQ_t>0:
 147        NVT_t  =numpy.zeros((NFREQ_t, NBV), int);
 148        l_t    =numpy.zeros((NBV, NFREQ_t), int);
 149     if NFREQ_l>0:
 150        NVT_l  =numpy.zeros((NFREQ_l, NBV), int);
 151        l_l    =numpy.zeros((NBV, NFREQ_l), int);
 152     else:
 153        NVT_l  = 0;
 154
 155     for ii in range(NBV):
 156         for jj in range(NFREQ_f):
 157             NVT_f[jj][ii]=lflex[ii,jj];
 158             l_f[ii][jj]  =lflex[ii,jj];
 159
 160         for jj in range(NFREQ_t):
 161             NVT_t[jj][ii]=ltors[ii,jj];
 162             l_t[ii][jj]  =ltors[ii,jj];
 163
 164         for jj in range(NFREQ_l):
 165             NVT_l[jj][ii]=llong[ii,jj];
 166             l_l[ii][jj]  =llong[ii,jj];
 167
 168     for ii in range(NBV):
 169         # ----------------------------------------------
 170         # Extraire la base des modes en flexion
 171         # ----------------------------------------------
 172         if NFREQ_f >0:
 173             lmodef =list(l_f[ii]);
 174             Mf[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii],
 175                                                         NUME_MODE = lmodef)
 176                                 );
 177
 178             Mf[ii]= NORM_MODE (MODE=Mf[ii],
 179                              reuse = Mf[ii],
 180                              NORME='TRAN',
 181                              );
 182
 183         # ----------------------------------------------
 184         # Extraire la base des modes en torsion
 185         # ----------------------------------------------
 186         if NFREQ_t >0:
 187             lmodet =list(l_t[ii]);
 188             Mt[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii],
 189                                                         NUME_MODE = lmodet)
 190                                 );
 191             Mt[ii]= NORM_MODE (MODE=Mt[ii],
 192                              reuse = Mt[ii],
 193                              AVEC_CMP=('DRX','DRY', 'DRZ'),
 194                              );
 195
 196         # ----------------------------------------------
 197         # Extraire la base des modes en longi
 198         # ----------------------------------------------
 199         if NFREQ_l >0:
 200             lmodel =list(l_l[ii]);
 201             Ml[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii],
 202                                                         NUME_MODE = lmodel)
 203                                 );
 204
 205             Ml[ii]= NORM_MODE (MODE=Ml[ii],
 206                              reuse = Ml[ii],
 207                              NORME='TRAN',
 208                              );
 209
 210     # -----------------------------------------------------------
 211     # Nombre de frequences par type pour le diagramme de Campbell
 212     # -----------------------------------------------------------
 213     NFREQ_fc=0;
 214     for jj in range(NFREQ_f):
 215         if NVT_f[jj][NBV-1]<= NFREQ_camp:
 216             NFREQ_fc=NFREQ_fc+1;
 217
 218     NFREQ_tc=0;
 219     for jj in range(NFREQ_t):
 220         if NVT_t[jj][NBV-1]<= NFREQ_camp:
 221             NFREQ_tc=NFREQ_tc+1;
 222
 223     NFREQ_lc=0;
 224     for jj in range(NFREQ_l):
 225         if NVT_l[jj][NBV-1]<= NFREQ_camp:
 226             NFREQ_lc=NFREQ_lc+1;
 227
 228     RESULT =[NFREQ_f,NFREQ_t,NFREQ_l,Mf,Mt,Ml,NVT,NVT_f,NVT_t,NVT_l,NFREQ_fc,NFREQ_tc,NFREQ_lc]
 229
 230     return RESULT
 231
 232
 233 #------------------------------------------------------------------------------------------------
 234 def EXTR_FREQ(self,L_MODES, L_MODEf,L_MODEt,L_MODEl, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l) :
 235     """Extraire les frequences"""
 236     RECU_TABLE        =self.get_cmd('RECU_TABLE')
 237     IMPR_TABLE        =self.get_cmd('IMPR_TABLE')
 238     DETRUIRE          =self.get_cmd('DETRUIRE')
 239
 240     RESULT=[];
 241
 242     NBV   =len(L_MODES);
 243     FRQ   =numpy.zeros((NFREQ,NBV));
 244     FRQ_f =numpy.zeros((NFREQ_f,NBV));
 245     FRQ_t =numpy.zeros((NFREQ_t,NBV));
 246     FRQ_l =numpy.zeros((NFREQ_l,NBV));
 247     AMO_f =numpy.zeros((NFREQ_f,NBV));
 248     FRQ_max = 0.0;
 249     EPSI    =1.E-10;
 250     for ii in range(NBV):
 251
 252         # frequences totales
 253         tabfreq = RECU_TABLE(CO=L_MODES[ii],NOM_PARA=('NUME_MODE','FREQ','AMOR_REDUIT'),);
 254
 255         for jj in range(NFREQ):
 256             FRQ[jj][ii]=tabfreq['FREQ',jj+1]
 257             if FRQ_max < FRQ[jj][ii]:
 258                 FRQ_max=FRQ[jj][ii];
 259
 260         if NFREQ_f>0:
 261             # frequences des modes en flexion
 262             tabfr_f = RECU_TABLE(CO=L_MODEf[ii],NOM_PARA=('FREQ','AMOR_REDUIT'),)
 263             for jj in range(NFREQ_f):
 264                 FRQ_f[jj][ii]=tabfr_f['FREQ',jj+1];
 265                 AMO_f[jj][ii]=tabfr_f['AMOR_REDUIT',jj+1];
 266                 if abs(AMO_f[jj][ii])<EPSI:
 267                     AMO_f[jj][ii]=0.0;
 268             DETRUIRE(CONCEPT=_F(NOM=(tabfr_f)),INFO=1)
 269
 270         if NFREQ_t>0:
 271             # frequences des modes en torsion
 272             tabfr_t = RECU_TABLE(CO=L_MODEt[ii],NOM_PARA='FREQ',)
 273
 274             for jj in range(NFREQ_t):
 275                 FRQ_t[jj][ii]=tabfr_t['FREQ',jj+1]
 276
 277             DETRUIRE(CONCEPT=_F(NOM=(tabfr_t)),INFO=1)
 278
 279         if NFREQ_l>0:
 280             # frequences des modes en traction / compression
 281             tabfr_l = RECU_TABLE(CO=L_MODEl[ii],NOM_PARA='FREQ',)
 282
 283             for jj in range(NFREQ_l):
 284                 FRQ_l[jj][ii]=tabfr_l['FREQ',jj+1]
 285
 286             DETRUIRE(CONCEPT=_F(NOM=(tabfr_l)),INFO=1)
 287
 288         DETRUIRE(CONCEPT=_F(NOM=(tabfreq)),INFO=1)
 289
 290
 291     RESULT = [FRQ,FRQ_f,FRQ_t, FRQ_l, FRQ_max, AMO_f];
 292     return RESULT
 293
 294
 295 #------------------------------------------------------------------------------------------------
 296
 297 def TRI_MODE_MACf(self, MACf,NFREQ_f, NVT_f, IV) :
 298     """Tri des frequences par calcul des coefficients MAC"""
 299
 300
 301     DETRUIRE          =self.get_cmd('DETRUIRE')
 302
 303     # base mode 1
 304     tmacf =numpy.zeros((NFREQ_f,NFREQ_f));
 305
 306     for jj in range(NFREQ_f):
 307         # base mode 2
 308         for ll in range(NFREQ_f):
 309             nmac= NFREQ_f*jj+ll
 310             tmacf[jj][ll]=MACf['MAC',nmac+1]
 311     chaine='MAC Modes de flexion'
 312     aster.affiche('RESULTAT', chaine)
 313     affiche_tab(tmacf,NFREQ_f, NFREQ_f);
 314
 315     for j2 in range(NFREQ_f):
 316         XMAX=0.0
 317         JREC=int(NVT_f[j2][IV+1]-1);
 318         for j1 in range(NFREQ_f):
 319
 320             if tmacf[j1][JREC] > XMAX:
 321                 XMAX=tmacf[j1][JREC]
 322                 I1B=j1+1
 323         # test d'existance de I1B dans le tableau de connexion
 324         I1B_exist =0;
 325         for jj in range(j2):
 326             if I1B == NVT_f[jj][IV]:
 327                 I1B_exist =1;
 328         if I1B_exist ==0:     # IB1 n'existe pas
 329             NVT_f[j2][IV]= I1B;
 330         else:
 331             NVT_f[j2][IV]=0;
 332
 333     DETRUIRE(CONCEPT=_F(NOM=(MACf)),INFO=1);
 334
 335     return NVT_f
 336
 337 #------------------------------------------------------------------------------------------------
 338
 339 def TRI_MODE_MACt(self, MACt,NFREQ_t, NVT_t, IV) :
 340     """Tri des frequences par calcul des coefficients MAC"""
 341
 342
 343     DETRUIRE          =self.get_cmd('DETRUIRE')
 344
 345     # base mode 1
 346     tmact =numpy.zeros((NFREQ_t,NFREQ_t));
 347
 348     for jj in range(NFREQ_t):
 349         # base mode 2
 350         for ll in range(NFREQ_t):
 351             nmac= NFREQ_t*jj+ll
 352             tmact[jj][ll]=MACt['MAC',nmac+1]
 353     chaine='MAC Modes en torsion'
 354     aster.affiche('RESULTAT', chaine)
 355     affiche_tab(tmact,NFREQ_t, NFREQ_t);
 356
 357     for j2 in range(NFREQ_t):
 358         XMAX=0.0
 359         JREC=int(NVT_t[j2][IV+1]-1);
 360         for j1 in range(NFREQ_t):
 361
 362             if tmact[j1][JREC] > XMAX:
 363                 XMAX=tmact[j1][JREC]
 364                 I1B=j1+1
 365         # test d'existance de I1B dans le tableau de connexion
 366         I1B_exist =0;
 367         for jj in range(j2):
 368             if I1B == NVT_t[jj][IV]:
 369                 I1B_exist =1; # IB1 existe deja
 370         if I1B_exist ==0:     # IB1 n'existe pas
 371             NVT_t[j2][IV]= I1B;
 372         else:
 373             NVT_t[j2][IV]=0;
 374
 375     DETRUIRE(CONCEPT=_F(NOM=(MACt)),INFO=1);
 376
 377     return NVT_t
 378
 379 #------------------------------------------------------------------------------------------------
 380 def TRI_MODE_MACl(self, MACl,NFREQ_l, NVT_l, IV) :
 381     """Tri des frequences par calcul des coefficients MAC"""
 382
 383     DETRUIRE          =self.get_cmd('DETRUIRE')
 384
 385     # base mode 1
 386     tmacl =numpy.zeros((NFREQ_l,NFREQ_l));
 387
 388     for jj in range(NFREQ_l):
 389         # base mode 2
 390         for ll in range(NFREQ_l):
 391             nmac= NFREQ_l*jj+ll
 392             tmacl[jj][ll]=MACl['MAC',nmac+1]
 393     chaine='MAC Modes en traction/compression'
 394     aster.affiche('RESULTAT', chaine)
 395     affiche_tab(tmacl,NFREQ_l, NFREQ_l);
 396
 397     for j2 in range(NFREQ_l):
 398         XMAX=0.0
 399         JREC=int(NVT_l[j2][IV+1]-1);
 400         for j1 in range(NFREQ_l):
 401
 402             if tmacl[j1][JREC] > XMAX:
 403                 XMAX=tmacl[j1][JREC]
 404                 I1B=j1+1
 405         # test d'existance de I1B dans le tableau de connexion
 406         I1B_exist =0;
 407         for jj in range(j2):
 408             if I1B == NVT_l[jj][IV]:
 409                 I1B_exist =1; # IB1 existe deja
 410         if I1B_exist ==0:     # IB1 n'existe pas
 411             NVT_l[j2][IV]= I1B;
 412         else:
 413             NVT_l[j2][IV]=0;
 414
 415     DETRUIRE(CONCEPT=_F(NOM=(MACl)),INFO=1);
 416
 417     return NVT_l
 418
 419
 420 #------------------------------------------------------------------------------------------------
 421 def CALC_MACf(self, L_MODEf, NFREQ_f) :
 422     """Calcul de la matrice MAC entre les deux bases successives"""
 423
 424     MAC_MODES         =self.get_cmd('MAC_MODES')
 425
 426     NBV=len(L_MODEf);
 427     tmacf =numpy.zeros((NFREQ_f,NFREQ_f));
 428     MACf=[0]*NBV
 429
 430     for ii in range(NBV-1):
 431         if NFREQ_f>0:
 432              MACf[ii]=MAC_MODES(BASE_1=L_MODEf[ii],
 433                    BASE_2=L_MODEf[ii+1],
 434                    INFO  =2,
 435                    );
 436     return MACf
 437
 438
 439 #------------------------------------------------------------------------------------------------
 440 def CALC_MACt(self, L_MODEt, NFREQ_t) :
 441     """Calcul de la matrice MAC entre les deux bases successives"""
 442
 443     MAC_MODES         =self.get_cmd('MAC_MODES')
 444
 445     NBV=len(L_MODEt);
 446     tmact =numpy.zeros((NFREQ_t,NFREQ_t));
 447     MACt=[0]*NBV
 448
 449     for ii in range(NBV-1):
 450         if NFREQ_t>0:
 451              MACt[ii]=MAC_MODES(BASE_1=L_MODEt[ii],
 452                    BASE_2=L_MODEt[ii+1],
 453                    INFO  =1,
 454                    );
 455     return MACt
 456
 457 #-----------------------------------------------------------------------------------------------
 458 def CALC_MACl(self, L_MODEl, NFREQ_l) :
 459     """Calcul de la matrice MAC entre les deux bases successives """
 460
 461     MAC_MODES         =self.get_cmd('MAC_MODES')
 462
 463     NBV=len(L_MODEl);
 464     tmacl =numpy.zeros((NFREQ_l,NFREQ_l));
 465     MACl=[0]*NBV
 466
 467     for ii in range(NBV-1):
 468         if NFREQ_l>0:
 469              MACl[ii]=MAC_MODES(BASE_1=L_MODEl[ii],
 470                    BASE_2=L_MODEl[ii+1],
 471                    INFO  =1,
 472                    );
 473     return MACl
 474
 475 #-----------------------------------------------------------------------------------------------
 476 def CALC_PREC(self,Mf,NFREQ_f,L_GR_NOEUD, typ_prec) :
 477     """Calcul le sens de precession pour un mode a une vitesse de rotation donnee
 478     Type de precession, 1 somme, 2 grande orbite"""
 479
 480     POST_RELEVE_T     =self.get_cmd('POST_RELEVE_T')
 481     DETRUIRE          =self.get_cmd('DETRUIRE')
 482     IMPR_TABLE        =self.get_cmd('IMPR_TABLE')
 483
 484     XSMIN=1e-2;
 485     NBV=len(Mf);
 486     NOEU=len(L_GR_NOEUD);
 487     SENS=numpy.zeros((NFREQ_f, NBV));
 488     for ii in range(NBV):
 489         # -------------------------------------------------------------------------
 490         # Extraire les parties reelles, imaginaires et modules des modes en flexion
 491         # -------------------------------------------------------------------------
 492
 493         tabmoR_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_REEL',
 494                                 NOEUD=L_GR_NOEUD,
 495                                 RESULTAT=Mf[ii],
 496                                 NOM_CHAM='DEPL',
 497                                 TOUT_ORDRE='OUI',
 498                                 NOM_CMP=('DX','DY','DZ'),
 499                                 FORMAT_C='REEL',
 500                                 OPERATION='EXTRACTION',),);
 501         tabmoI_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_IMAG',
 502                                 NOEUD=L_GR_NOEUD,
 503                                 RESULTAT=Mf[ii],
 504                                 NOM_CHAM='DEPL',
 505                                 TOUT_ORDRE='OUI',
 506                                 NOM_CMP=('DX','DY','DZ'),
 507                                 FORMAT_C='IMAG',
 508                                 OPERATION='EXTRACTION',),);
 509         tabmoN_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_MODULE',
 510                                 NOEUD=L_GR_NOEUD,
 511                                 RESULTAT=Mf[ii],
 512                                 NOM_CHAM='DEPL',
 513                                 TOUT_ORDRE='OUI',
 514                                 NOM_CMP=('DX','DY','DZ'),
 515                                 FORMAT_C='MODULE',
 516                                 OPERATION='EXTRACTION',),);
 517
 518
 519         for jj in range(NFREQ_f):
 520             #Sens de precesion pour un mode a une vitesse donne
 521             modul1  =0.0;
 522             sens1   =0.0;
 523             for ll in range(NOEU):
 524                 nmod=NOEU*jj+ll
 525                 dy_r  = tabmoR_f['DY' ,nmod+1];
 526                 dz_r  = tabmoR_f['DZ' ,nmod+1];
 527                 dy_i  = tabmoI_f['DY' ,nmod+1];
 528                 dz_i  = tabmoI_f['DZ' ,nmod+1];
 529                 dy_m  = tabmoN_f['DY' ,nmod+1];
 530                 dz_m  = tabmoN_f['DZ' ,nmod+1];
 531
 532                 if typ_prec == 1 :
 533                     #Sens parcours pour un noeud
 534                     preces  = dy_r*dz_i-dy_i*dz_r ;
 535                     #Sens de precession dominant dans une mode
 536                     if preces >0:
 537                         sens1=sens1+ dy_m + dz_m;
 538                     elif preces <0:
 539                         sens1=sens1- dy_m - dz_m;
 540                 else:
 541                     #Sens de precession associe au plus grand orbite
 542                     lk= numpy.sqrt(dy_m*dy_m + dz_m*dz_m);
 543                     if lk > modul1:
 544                         # demi diagonale
 545                         modul1=lk
 546                         preces  = dy_r*dz_i-dy_i*dz_r ;
 547                         if preces >0:
 548                             sens1=modul1;
 549                         elif preces <0:
 550                             sens1=-modul1;
 551
 552             XS=abs(sens1);
 553             if XS>XSMIN:
 554                 SENS[jj][ii]=sens1/XS;
 555             else:
 556                 SENS[jj][ii]=0.0;
 557
 558         DETRUIRE(CONCEPT=_F(NOM=(tabmoR_f, tabmoI_f, tabmoN_f)),INFO=1)
 559
 560     return SENS
 561
 562 #------------------------------------------------------------------------------------------------
 563 def TRI_MODE_PREC_DI (SENS,NFREQ_f, NVT_f, NBV, OMIN) :
 564     """Tri des modes par une methode de proche en proche avec verification du sens de precession"""
 565     # base mode 1
 566     chaine='TRI_MODE_PREC_DI'
 567     aster.affiche('RESULTAT', chaine)
 568
 569     NVT_fdir =numpy.zeros((NFREQ_f, NBV));
 570     NVT_finv =numpy.zeros((NFREQ_f, NBV));
 571     nb_prec_dir =NFREQ_f;
 572     nb_prec_inv =NFREQ_f;
 573     for nb in range(NBV):
 574         nbv1=NBV-nb-1;
 575         jd=0;
 576         ji=0;
 577         for jj in range(NFREQ_f):
 578             if SENS[jj][nbv1]>=0.:
 579                 NVT_fdir[jd][nbv1]=jj+1;
 580                 jd=jd+1;
 581             elif SENS[jj][nbv1]<0.:
 582                 NVT_finv[ji][nbv1]=jj+1;
 583                 ji=ji+1;
 584         # Calcul de nombre minimum de precession directe pour les vitesses
 585         # Calcul de nombre minimum de precession inverse pour les vitesses
 586
 587         if jd>0:
 588             if nb_prec_dir >jd:
 589                 nb_prec_dir =jd;
 590         if ji>0:
 591             if nb_prec_inv >ji:
 592                 nb_prec_inv= ji;
 593
 594     if(OMIN==0.0) :
 595         for ii in range(NFREQ_f):
 596             NVT_fdir[ii][0]=NVT_fdir[ii][1]
 597             NVT_finv[ii][0]=NVT_finv[ii][1]
 598
 599     chaine='nb_prev_dir ' + str(nb_prec_dir);
 600     aster.affiche('RESULTAT', chaine)
 601     chaine='Tableau de connexion des Modes de flexion precession directe'
 602     aster.affiche('RESULTAT', chaine)
 603     affiche_tabint(NVT_fdir,NFREQ_f, NBV);
 604
 605     chaine='nb_prev_inv ' + str(nb_prec_inv);
 606     aster.affiche('RESULTAT', chaine)
 607     chaine='Tableau de connexion des Modes de flexion precession inverse'
 608     aster.affiche('RESULTAT', chaine)
 609     affiche_tabint(NVT_finv,NFREQ_f, NBV);
 610
 611     # Rassembler les tableaux de connexion
 612     NVTf_prec =numpy.zeros((NFREQ_f, NBV), int);
 613     for jj in range(NFREQ_f):
 614         jf=0;
 615         jf=int(NVT_fdir[jj][NBV-1]);
 616         if jf>0:
 617             for iv in range(NBV):
 618                 NVTf_prec[jf-1][iv]= NVT_fdir[jj][iv];
 619         jf=0;
 620         jf=int(NVT_finv[jj][NBV-1]);
 621         if jf>0:
 622             for iv in range(NBV):
 623                 NVTf_prec[jf-1][iv]= NVT_finv[jj][iv];
 624
 625     chaine='\n'
 626     aster.affiche('RESULTAT', chaine)
 627     chaine='Tableau de connexion des Modes de flexion'
 628     aster.affiche('RESULTAT', chaine)
 629     affiche_tabint(NVTf_prec,NFREQ_f, NBV);
 630
 631     RESULT = [nb_prec_dir,nb_prec_inv, NVTf_prec];
 632
 633     return RESULT
 634
 635
 636 #----------------------------------------------------------------------------------------
 637 def affiche_tab(tab1,nbligne, nbcol) :
 638     """affiche un taleau tab1 de nbligne lignes et nbcol colonnes"""
 639     for jj in range(nbligne):
 640         chaine=''
 641         for ii in range(nbcol):
 642             str1 = '%15.5E' %tab1[jj][ii]
 643             chaine=chaine + ' '+ str1
 644         aster.affiche('RESULTAT', chaine)
 645
 646
 647 #----------------------------------------------------------------------------------------
 648 def affiche_tabint(tab1,nbligne, nbcol) :
 649     """affiche un taleau tab1 de nbligne lignes et nbcol colonnes"""
 650     for jj in range(nbligne):
 651         chaine=''
 652         for ii in range(nbcol):
 653             str1 = '%5d' %tab1[jj][ii]
 654             chaine=chaine + ' '+ str1
 655         aster.affiche('RESULTAT', chaine)
 656
 657
 658 #----------------------------------------------------------------------------------------
 659 def calc_pas(xmin, xmax) :
 660     """calcul de l'echelle valeurs mini-maxi et le pas
 661     On impose entre 5 et 10 intervalles
 662     En entree xmin, xmax valeurs mini-maxi, xmin et xmax superieurs ou egaux a zero
 663     En sortie VAL1, VAL2 et PAS valeurs mini-maxi de l'echelle et le pas
 664     """
 665     diff=xmax-xmin;
 666     PAS=1.;
 667     VAL1=0.;
 668     C10=10.;
 669
 670     # diff < 5.
 671     while diff<5.:
 672         diff=diff*C10;
 673         PAS = PAS/C10;
 674
 675     # diff > 50.
 676     while diff<50.:
 677         diff=diff/C10;
 678         PAS = PAS*C10;
 679
 680     # 5 <= diff <= 50.
 681     N=int(diff);
 682     if N>=11 and N<=20 :
 683         N=N/2;
 684         PAS=PAS*2.;
 685     elif N>=21 and N<=30 :
 686         N=N/3;
 687         PAS=PAS*3.;
 688     elif N>=31 and N<=40 :
 689         N=N/4;
 690         PAS=PAS*4.;
 691     elif N>=41 and N<=50 :
 692         N=N/5;
 693         PAS=PAS*5.;
 694
 695     # Calcul des valeurs mini-maxi de l'echelle
 696     while abs(xmin-VAL1)>PAS:
 697         VAL1=VAL1 + PAS;
 698
 699     VAL2=VAL1 + (N*PAS);
 700     while VAL2 <= xmax:
 701         VAL2=VAL2 + PAS;
 702
 703     RESULT=[VAL1, VAL2, PAS];
 704
 705     return RESULT
 706
 707 #----------------------------------------------------------------------------------------
 708 def color_camp(sens, amortis) :
 709     """determine la couleur et le style du trait
 710     en entree le sens de precession
 711     en sortir la couleur, le style du trait ICS IST et le marqueur
 712           DIRECTE,STABLE       vert
 713           DIRECTE,INSTABLE     rouge
 714           INDIRECTE,STABLE     bleu
 715           INDIRECTE,INSTABLE   magenta
 716     """
 717
 718     if sens<0:   # precession inverse
 719         if amortis<0.0:   # instable
 720             ICS = 10; # magenta
 721             IST = 4;  # tiret
 722             IMA = 9;  # croix
 723         else:           # stable
 724             ICS = 4;  # bleu
 725             IST = 4;  # tiret
 726             IMA = 0;
 727     else:       # precession directe
 728         if amortis<0.0:   # instable
 729             ICS = 2;  # rouge
 730             IST = 1;  # trait continu
 731             IMA = 8;  # plus
 732         else:           # stable
 733             ICS = 3;  # vert
 734             IST = 1;  # trait continu
 735             IMA = 0;
 736     RESULT= [ICS,IST,IMA];
 737
 738     return RESULT
 739
 740 #----------------------------------------------------------------------------------------
 741 def sup_redon_list(LS):
 742     """Supprimer la redondace dans une liste de reel"""
 743     LS.sort();
 744     LS_min=min(LS);
 745     LS_max=max(LS);
 746     if  LS_min<0:
 747         if abs(LS_min) > abs(LS_max):
 748             LS.reverse();
 749     ii=0
 750     len_list=len(LS);
 751     while ii < len_list-1:
 752         icount = LS.count(LS[ii]);
 753         if icount >1:
 754             for jj in range(ii+icount-1, ii,-1):
 755                 LS.pop(jj);
 756         ii=ii+1
 757         len_list=len(LS);
 758
 759
 760 #----------------------------------------------------------------------------------------
 761 def sup_redon_listv(LS):
 762     """Supprimer la redondace dans une liste de vitesses"""
 763
 764     LS_init=[LS[ii] for ii in range(len(LS))]; # Liste de vitesses initiale sans rangement
 765     LS.sort();
 766     LS_min=min(LS);
 767     LS_max=max(LS);
 768     if  LS_min<0:
 769         if abs(LS_min) > abs(LS_max):
 770             LS.reverse();
 771
 772     ii=0
 773     len_list=len(LS);
 774     while ii < len_list-1:
 775         icount = LS.count(LS[ii]);
 776         if icount >1:
 777             for jj in range(ii+icount-1, ii,-1):
 778                 LS.pop(jj);
 779         ii=ii+1
 780         len_list=len(LS);
 781
 782
 783     nbV1=len_list;
 784     num_vit_tri =numpy.zeros((nbV1), int);
 785     for ii in range(0,nbV1):
 786         vit = LS[ii];
 787         num_vit_tri[ii] = LS_init.index(vit);
 788
 789     print 'LS', LS
 790     print 'LS_init', LS_init
 791     return num_vit_tri
 792
 793
 794 #----------------------------------------------------------------------------------------
 795 def save_intersec(L_INTER, FINT):
 796     """Sauvegarde dans un fichier les points d'intersection des courbes du diagramme de Campbell
 797     avec les droites de pente S
 798     """
 799     chaine='\n'
 800     FINT.write(chaine)
 801     chaine='Points d'' intersection avec les droites Y=SX'
 802     FINT.write(chaine)
 803     for ii in range(len(L_INTER)):
 804         chaine='\n'
 805         FINT.write(chaine)
 806         chaine = 'S = %10.2F' %L_INTER[ii]["pente"]
 807         FINT.write(chaine)
 808         chaine='\n'
 809         FINT.write(chaine)
 810         L_POINT = L_INTER[ii]["point"]
 811         for jj in range(len(L_POINT)):
 812             chaine = 'Vitesse   = %10.2F tr/mn' %L_POINT[jj][0]
 813             FINT.write(chaine)
 814             FINT.write('\n')
 815             chaine = 'Frequence = %10.2F HZ' %L_POINT[jj][1]
 816             FINT.write(chaine)
 817             FINT.write('\n')
 818
 819         chaine='----------------------------'
 820         FINT.write(chaine)
 821         chaine='\n'
 822         chaine=' '
 823