Aster/Cata/cataSTA9/Macro/macr_ecrevisse_ops.py

   1 #@ MODIF macr_ecrevisse_ops Macro  DATE 05/05/2010   AUTEUR MACOCCO K.MACOCCO
   2 # -*- coding: iso-8859-1 -*-
   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
  21 def macr_ecrevisse_ops(self,reuse,
  22    CONV_CRITERE,
  23    TABLE,
  24    TEMPER,
  25    DEBIT,
  26    MODELE_MECA,
  27    MODELE_THER,
  28    FISSURE,
  29    ECOULEMENT,
  30    LIST_INST,
  31    MODELE_ECRE,
  32    CONVERGENCE_ECREVISSE,
  33    COURBES,
  34    LOGICIEL,
  35    VERSION,
  36    ENTETE,
  37    IMPRESSION,
  38    CHAM_MATER,
  39    CARA_ELEM,
  40    EXCIT_MECA,
  41    EXCIT_THER,
  42    COMP_INCR,
  43    NEWTON,
  44    CONVERGENCE,
  45    ETAT_INIT,
  46    INFO,
  47    **args):
  48    """
  49         Procedure de couplage Aster-Ecrevisse
  50         Execution pour tous les pas de temps des calculs thermiques, mecaniques puis hydraulique
  51         DecoupageGeneration par Aster du fichier de donnees d'Ecrevisse et lancement d'Ecrevisse
  52    """
  53
  54
  55    from Utilitai.Utmess import UTMESS
  56    from Utilitai.Table import Table, merge
  57    from Accas import _F
  58    import os, aster, copy
  59
  60    ier=0
  61    #
  62    # La macro compte pour 1 dans la numerotation des commandes
  63    self.set_icmd(1)
  64
  65    # Parametres debug
  66    debug = False
  67
  68    # Info
  69    InfoAster = 1
  70    info2 = (INFO==2)
  71    if debug :
  72        info2=True
  73
  74    # IMPORTATION DE COMMANDES ASTER
  75    DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL")
  76    THER_LINEAIRE  = self.get_cmd("THER_LINEAIRE")
  77    PROJ_CHAMP     = self.get_cmd("PROJ_CHAMP")
  78    DETRUIRE       = self.get_cmd("DETRUIRE")
  79    AFFE_MATERIAU  = self.get_cmd("AFFE_MATERIAU")
  80    STAT_NON_LINE  = self.get_cmd("STAT_NON_LINE")
  81    POST_RELEVE_T  = self.get_cmd("POST_RELEVE_T")
  82    CALC_ECREVISSE = self.get_cmd("CALC_ECREVISSE")
  83    CO             = self.get_cmd("CO")
  84    CREA_TABLE     = self.get_cmd("CREA_TABLE")
  85    CREA_RESU      = self.get_cmd("CREA_RESU")
  86    CREA_CHAMP     = self.get_cmd("CREA_CHAMP")
  87
  88    # Concepts sortants
  89    # TABLE creees par concatenation des tables sorties par CALC_ECREVISSE a chaque iteration
  90    self.DeclareOut('TABL_RES',TABLE)
  91    self.DeclareOut('DEB_RES',DEBIT)
  92    # Concepts sortant: les resultats de STAT_NON_LINE et de THER_LINEAIRE valides vis-a-vis du calcul ecrevisse
  93    self.DeclareOut('RTHERM',TEMPER)
  94    self.DeclareOut('MECANIC', self.sd)
  95
  96    IsPoursuite = False
  97    IsInit = True
  98    # Traitement de l'etat initial en cas de poursuite
  99    if ETAT_INIT:
 100        dEtatInit=ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste)
 101        for i in dEtatInit.keys():
 102            if dEtatInit[i]==None : del dEtatInit[i]
 103        __EVINIT = dEtatInit['EVOL_NOLI']
 104        __THINIT = dEtatInit['EVOL_THER']
 105        _nume_ordre = dEtatInit['NUME_ORDRE']
 106        IsPoursuite= True
 107    else :
 108        dEtatInit=None
 109
 110    ## Valeur par defaut du mot cle LOGICIEL
 111    #if not LOGICIEL: LOGICIEL = os.path.join(aster.repout(), 'ecrevisse')
 112
 113    # RECUPERATION DES MOTS-CLES FACTEURS
 114
 115    l_dFISSURE=[]
 116    for fissure in FISSURE:
 117       dFISSURE=fissure.cree_dict_valeurs(fissure.mc_liste)
 118       for i in dFISSURE.keys():
 119          if dFISSURE[i]==None : del dFISSURE[i]
 120       l_dFISSURE.append(dFISSURE)
 121
 122    dECOULEMENT=ECOULEMENT[0].cree_dict_valeurs(ECOULEMENT[0].mc_liste)
 123    for i in dECOULEMENT.keys():
 124       if dECOULEMENT[i]==None : del dECOULEMENT[i]
 125
 126    dMODELE_ECRE=MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
 127    for i in dMODELE_ECRE.keys():
 128       if dMODELE_ECRE[i]==None : dMODELE_ECRE[i]=None #del dMODELE_ECRE[i]
 129
 130    dCONVERGENCE_ECREVISSE=CONVERGENCE_ECREVISSE[0].cree_dict_valeurs(CONVERGENCE_ECREVISSE[0].mc_liste)
 131    for i in dCONVERGENCE_ECREVISSE.keys():
 132       if dCONVERGENCE_ECREVISSE[i]==None : del dCONVERGENCE_ECREVISSE[i]
 133
 134    dCOMP_INCR=COMP_INCR[0].cree_dict_valeurs(COMP_INCR[0].mc_liste)
 135    for i in dCOMP_INCR.keys():
 136       if dCOMP_INCR[i]==None : del dCOMP_INCR[i]
 137
 138    dNEWTON=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
 139    for i in dNEWTON.keys():
 140       if dNEWTON[i]==None : del dNEWTON[i]
 141
 142    dCONVERGENCE=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
 143    for i in dCONVERGENCE.keys():
 144       if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
 145
 146    # Recuperation des infos pour la convergence de la macro
 147    dMacr_Conv = CONV_CRITERE[0].cree_dict_valeurs(CONV_CRITERE[0].mc_liste)
 148    for i in dMacr_Conv.keys():
 149       if dMacr_Conv[i]==None : del dMacr_Conv[i]
 150
 151    motclefsCALC_ECREVISSE = {}
 152    motclefsCALC_ECREVISSE['COURBES'] = COURBES,
 153
 154
 155
 156
 157
 158    # -----------------------------------------------------------------------------------------------------
 159    # Debut de la macro
 160
 161    # Si LIST_INST est un DEFI_LIST_REEL :
 162    _liste_inst = LIST_INST.Valeurs()
 163    if (debug):
 164       print 'liste des instants liste_inst = ', _liste_inst
 165
 166    # Drapeaux pour les 1ers calculs et les 1eres definitions
 167    IsDefineMaterMeca  = False
 168    EcrevisseExe       = False  # si l'execution d'Ecrevisse n'a pas plantee ou a ete realisee
 169
 170    # Table python devant contenir toutes les tables Ecrevisse
 171    T_TABL_RES = None
 172    T_DEB_RES  = None
 173    # Precision demandee pour converger sur le critere de la macro
 174    # Nombre de decoupages succesifs d'un pas de temps
 175    # Pas de temps en dessous duquel on ne decoupe plus
 176    if dMacr_Conv.has_key('SUBD_NIVEAU'):
 177        MacrNbDecoupage   = dMacr_Conv['SUBD_NIVEAU']
 178    if dMacr_Conv.has_key('SUBD_PAS_MINI'):
 179        MacrPasMini       = dMacr_Conv['SUBD_PAS_MINI']
 180    MacrTempRef       = dMacr_Conv['TEMP_REF']
 181    MacrPresRef       = dMacr_Conv['PRES_REF']
 182    MacrCritere       = dMacr_Conv['CRITERE']
 183    if dMacr_Conv.has_key('PREC_CRIT'):
 184       MacrPrecisCritere = dMacr_Conv['PREC_CRIT']
 185    else:
 186       MacrPrecisCritere = None
 187    if dMacr_Conv.has_key('NUME_ORDRE_MIN'):
 188       MacrNumeOrdre     = dMacr_Conv['NUME_ORDRE_MIN']
 189
 190    #
 191    # il faut 2 pas au minimum dans la liste
 192    if (len(_liste_inst) < 2 ):
 193       UTMESS('F','ECREVISSE0_20', vali=[2])
 194
 195    if (not IsPoursuite) :
 196      _nume_ordre = 0
 197    else :
 198      # Dans le cas d'une poursuite :
 199      # n reconstruit une nouvelle liste d'instant composee de l'ancienne liste jusqu'a l'instant recherche,
 200      # puis de la nouvelle a partir de cet instant
 201      # ainsi le _nume_ordre de la nouvelle liste correspond au nume_ordre de l'ancienne
 202      __dico1 = __THINIT.LIST_VARI_ACCES()
 203      _list_precedente = __dico1['INST']
 204      _inst_init  = _list_precedente[_nume_ordre-1]
 205      try:
 206         # si l'instant est dans la liste, on recupere l'index
 207         _idx = _liste_inst.index(_inst_init)
 208      except:
 209         # on cherche le plus proche
 210         idx = 0
 211         found = False
 212         for t in _liste_inst:
 213            if t > _inst_init:
 214               found = True
 215               idx += 1
 216               break
 217            idx += 1
 218      new_list = _list_precedente[0:_nume_ordre]  # liste precedent jusqu'a l'instant a recalculer (inclu, ca permet de gerer le cas ou l'instant a recalculer n'est pas dans la nouvelle liste : il sera ajoute)
 219      new_list.extend( _liste_inst[_idx+1:] )  # on lui ajoute la nouvelle liste a partir du l'instant a recalculer
 220      _liste_inst = copy.copy(new_list)
 221
 222    ########################################################################################
 223    # Debut boucle sur la liste d'instant
 224    ########################################################################################
 225    FinBoucle = False
 226    while ( not FinBoucle ):
 227       _inst      = _liste_inst[_nume_ordre]
 228       if ( debug ):
 229           print 'Instant debut boucle', _inst
 230       # On boucle jusqu'a convergence
 231       NbIter = 0
 232       while True:
 233
 234
 235          if ( (not IsPoursuite) or EcrevisseExe) :
 236          # Le temps que l'on traite
 237            _inst_p_un = _liste_inst[_nume_ordre+1]
 238            IsInitEcre= False
 239            # Construction de la liste des pas
 240            LES_PAS = DEFI_LIST_REEL( VALE=_liste_inst, )
 241            if (debug):
 242               print '=====> ===== ===== ===== <===='
 243               print 'Iteration numero : ', NbIter
 244               print 'Instant          : ', _inst
 245               print 'Instant+1        : ', _inst_p_un
 246               print 'nume_ordre       : ', _nume_ordre+1
 247               print 'Donnee Ecrevisse : ', EcrevisseExe
 248
 249            # ---------------------
 250            #        THERMIQUE
 251            # ---------------------
 252            # Recuperation des chargements thermiques
 253            _dEXCIT_THER = []
 254            if EXCIT_THER:
 255              for excit_i in EXCIT_THER:
 256                dEXCIT_THER_i = excit_i.cree_dict_valeurs(excit_i.mc_liste)
 257                for j in dEXCIT_THER_i.keys():
 258                   if dEXCIT_THER_i[j]==None : del dEXCIT_THER_i[j]
 259                _dEXCIT_THER.append(dEXCIT_THER_i)
 260
 261          #
 262          # Definition des chargements thermiques venant d Ecrevisse
 263            if ( EcrevisseExe ):
 264               _dEXCIT_THER.append( _F(CHARGE=FLU1ECR0) )
 265               _dEXCIT_THER.append( _F(CHARGE=FLU2ECR0) )
 266
 267            # Definition de l'etat initial
 268            motclefs = {}
 269            if (_nume_ordre == 0) :
 270               # On verifie que temp_ref est bien renseigne dans AFFE_MATERIAU
 271               try:
 272                  tref = CHAM_MATER['AFFE_VARC']['VALE_REF']
 273               except:
 274                  UTMESS('F','ECREVISSE0_22',)
 275
 276               motclefs['ETAT_INIT']=[_F(VALE=tref, NUME_ORDRE=_nume_ordre)]
 277               if ( debug ):
 278                  print 'thermique initialise avec tref'
 279            else:
 280               if (IsInit) :
 281                  motclefs['reuse']=__THINIT
 282                  motclefs['ETAT_INIT']=[_F(EVOL_THER=__THINIT,  NUME_ORDRE=_nume_ordre)]
 283                  if (debug):
 284                     print 'thermique initialise avec etat_initial'
 285               else :
 286                  motclefs['reuse']=RTHERM
 287                  motclefs['ETAT_INIT']=[_F(EVOL_THER=RTHERM,  NUME_ORDRE=_nume_ordre)]
 288                  if (debug):
 289                     print 'thermique initialise avec instant precedent'
 290
 291            if (debug):
 292               print '====> THER_LINEAIRE <===='
 293               print '   Les charges thermiques'
 294               print EXCIT_THER
 295          #
 296            if IsPoursuite :
 297               __THINIT = THER_LINEAIRE(
 298                 MODELE     = MODELE_THER,
 299                 CHAM_MATER = CHAM_MATER,
 300                 EXCIT      = _dEXCIT_THER,
 301                 INCREMENT  = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,),
 302                 ARCHIVAGE  = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
 303                 INFO       = InfoAster,
 304                 **motclefs )
 305
 306               RTHERMPJ=PROJ_CHAMP(RESULTAT=__THINIT, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
 307                      VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
 308                      INFO=2,
 309                       )
 310               RTHERM=__THINIT
 311            else :
 312               RTHERM=THER_LINEAIRE(
 313                MODELE     = MODELE_THER,
 314                CHAM_MATER = CHAM_MATER,
 315                EXCIT      = _dEXCIT_THER,
 316                INCREMENT  = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,),
 317                ARCHIVAGE  = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
 318                INFO       = InfoAster,
 319                **motclefs
 320                )
 321
 322            # Projection du champ thermique, a tous les instants sinon pas de deformations thermiques
 323               RTHERMPJ=PROJ_CHAMP(RESULTAT=RTHERM, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
 324                 VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
 325                 INFO=2,
 326                  )
 327
 328          # Definition du materiau pour la mecanique : a faire une seule fois
 329            if ( not IsDefineMaterMeca ):
 330               motclefmater = {}
 331               motclefmater['AFFE'] = []
 332               motclefmater['AFFE_VARC'] = []
 333
 334               for j in CHAM_MATER['AFFE_VARC'] :
 335                  dvarc = j.cree_dict_valeurs(j.mc_liste)
 336                  for mc, val in dvarc.items():
 337                     if val == None:
 338                        del dvarc[mc]
 339                  motclefmater['AFFE_VARC'].append(dvarc)
 340
 341               for j in CHAM_MATER['AFFE'] :
 342                  daffe = j.cree_dict_valeurs(j.mc_liste)
 343                  for mc, val in daffe.items():
 344                     if val == None:
 345                        del daffe[mc]
 346                  motclefmater['AFFE'].append(daffe)
 347
 348
 349               dvarc['EVOL'] = RTHERMPJ
 350               motclefmater['MAILLAGE'] = CHAM_MATER['MAILLAGE']
 351               __MATMEC=AFFE_MATERIAU(
 352                  **motclefmater
 353               )
 354               IsDefineMaterMeca = True
 355
 356            # ---------------------
 357            #        MECANIQUE
 358            # ---------------------
 359            _dEXCIT_MECA = []
 360            # Recuperation des chargements mecaniques
 361            if EXCIT_MECA:
 362               for excit_i in EXCIT_MECA:
 363                  dEXCIT_MECA_i = excit_i.cree_dict_valeurs(excit_i.mc_liste)
 364                  for j in dEXCIT_MECA_i.keys():
 365                     if dEXCIT_MECA_i[j]==None : del dEXCIT_MECA_i[j]
 366                  _dEXCIT_MECA.append(dEXCIT_MECA_i)
 367
 368
 369            # Definition des chargements venant d'Ecrevisse
 370            if ( EcrevisseExe ):
 371               _dEXCIT_MECA.append( _F(CHARGE=MECAECR0) )
 372
 373            motclefs = {}
 374
 375            if (not IsPoursuite) :
 376              if (_nume_ordre != 0):
 377                 motclefs['reuse'] = MECANIC
 378                 motclefs['ETAT_INIT']=[_F(EVOL_NOLI=MECANIC, NUME_ORDRE=_nume_ordre)]
 379                 if (debug):
 380                    print 'etat meca initial = pas precedent'
 381              else:
 382                 if (debug):
 383                    print 'etat meca initial : vierge'
 384            else:
 385               motclefs['reuse']=__EVINIT
 386               motclefs['ETAT_INIT']=[_F(EVOL_NOLI=__EVINIT, NUME_ORDRE=_nume_ordre)]
 387               if (debug):
 388                  print 'etat meca initial dReuseM', motclefs
 389
 390            if (debug):
 391               print '====> STAT_NON_LINE <===='
 392            if (debug):
 393               print '   Les charges mecaniques'
 394               print _dEXCIT_MECA
 395
 396
 397            MECANIC=STAT_NON_LINE(
 398               MODELE      = MODELE_MECA,
 399               CHAM_MATER  = __MATMEC,
 400               CARA_ELEM   = CARA_ELEM,
 401               EXCIT       = _dEXCIT_MECA,
 402               COMP_INCR   = _F(**dCOMP_INCR),
 403               INCREMENT   = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,),
 404               NEWTON      = _F(**dNEWTON),
 405               CONVERGENCE = _F(**dCONVERGENCE),
 406               SOLVEUR     = _F(SYME='OUI'),
 407               ARCHIVAGE   = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
 408               INFO        = InfoAster,
 409               **motclefs
 410            )
 411            # Destruction des concepts
 412            #  Thermique projete
 413            #  Liste des pas
 414            DETRUIRE( CONCEPT=(_F(NOM=RTHERMPJ),_F(NOM=LES_PAS),),INFO=1,ALARME='NON',)
 415
 416          else :
 417            #      CAS OU LA MACRO EST REENTRANTE : ON RELANCE ECREVISSE POUR CONNAITRE
 418            #     LES CHARGEMENT A UTILISER POUR LES PROBLEMES THERMIQUES ET MECANIQUES
 419            _inst_p_un=_inst
 420            IsInitEcre = True
 421
 422          # -----------------------------------------------------------------------
 423          #        ECREVISSE : ATTENTION SI REPRISE CALCUL, ON RECALCULE LE DERNIER INSTANT
 424          # -------------------------------------------------------------------------
 425          # Si Ecrevisse a deja ete fait une fois.
 426          #   ==> Efface les concepts qui sont en sortie
 427          if ( EcrevisseExe ):
 428             DETRUIRE(
 429                CONCEPT=(
 430                   _F(NOM=MECAECR1),
 431                   _F(NOM=FLU1ECR1),
 432                   _F(NOM=FLU2ECR1),
 433                   _F(NOM=TABLECR1),
 434                   _F(NOM=DEBIECR1),
 435                ),INFO=1,ALARME='NON',
 436             )
 437
 438          # On remplace FONC_XXX par la valeur XXX correspondante a l'instant _inst_p_un
 439          dECOULEMENT_ecrevisse = copy.copy(dECOULEMENT)
 440          for fonc_name in ["PRES_ENTREE_FO", "PRES_SORTIE_FO", "PRES_PART_FO", "TITR_MASS_FO", "TEMP_ENTREE_FO"]:
 441             if dECOULEMENT.has_key(fonc_name):
 442                fonc = dECOULEMENT_ecrevisse.pop(fonc_name)
 443                vale_name = fonc_name.replace('_FO', '')
 444                dECOULEMENT_ecrevisse[vale_name] = fonc(_inst_p_un)
 445
 446
 447          # Initialisation des concepts en sortie
 448          MECAECR1=CO('MECAECR1')
 449          FLU1ECR1=CO('FLU1ECR1')
 450          FLU2ECR1=CO('FLU2ECR1')
 451          TABLECR1=CO('TABLECR1')
 452          DEBIECR1=CO('DEBIECR1')
 453
 454          if (debug):
 455             print '====> ECREVISSE entree dans CALC_ECREVISSE <===='
 456
 457          if (not IsPoursuite) :
 458
 459            CALC_ECREVISSE(
 460               CHARGE_MECA      = MECAECR1,
 461               CHARGE_THER1     = FLU1ECR1,
 462               CHARGE_THER2     = FLU2ECR1,
 463               TABLE            = TABLECR1,
 464               DEBIT            = DEBIECR1,
 465               MODELE_MECA      = MODELE_MECA,
 466               MODELE_THER      = MODELE_THER,
 467               ENTETE           = ENTETE,
 468               IMPRESSION       = IMPRESSION,
 469               INFO             = INFO,
 470               RESULTAT=_F(THERMIQUE  = RTHERM,
 471                         MECANIQUE  = MECANIC,
 472                         INST       = _inst_p_un, ),
 473               # chemin d acces a Ecrevisse
 474               LOGICIEL         = LOGICIEL,
 475               VERSION          = VERSION,
 476               # donnees necessaire pour ecrevisse
 477               # assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
 478               # activation eventuelle de TITR_VA et P_AIR
 479
 480               FISSURE=l_dFISSURE,
 481               ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
 482               MODELE_ECRE=_F( **dMODELE_ECRE),
 483
 484               CONVERGENCE=_F( **dCONVERGENCE_ECREVISSE ),
 485               **motclefsCALC_ECREVISSE
 486               );
 487          else :
 488            CALC_ECREVISSE(
 489               CHARGE_MECA      = MECAECR1,
 490               CHARGE_THER1     = FLU1ECR1,
 491               CHARGE_THER2     = FLU2ECR1,
 492               TABLE            = TABLECR1,
 493               DEBIT            = DEBIECR1,
 494               MODELE_MECA      = MODELE_MECA,
 495               MODELE_THER      = MODELE_THER,
 496               ENTETE           = ENTETE,
 497               IMPRESSION       = IMPRESSION,
 498               INFO             = INFO,
 499               RESULTAT=_F(THERMIQUE  = __THINIT,
 500                           MECANIQUE  = __EVINIT,
 501                           INST       = _inst_p_un, ),
 502               # chemin d acces a Ecrevisse
 503               LOGICIEL         = LOGICIEL,
 504               VERSION          = VERSION,
 505               # donnees necessaire pour ecrevisse
 506               # assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
 507               # activation eventuelle de TITR_VA et P_AIR
 508
 509               FISSURE=l_dFISSURE,
 510               ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
 511               MODELE_ECRE=_F( **dMODELE_ECRE),
 512
 513               CONVERGENCE=_F( **dCONVERGENCE_ECREVISSE ),
 514               **motclefsCALC_ECREVISSE
 515               );
 516
 517          if (debug):
 518             print '====> ECREVISSE sortie de CALC_ECREVISSE <===='
 519
 520
 521          # Recuperation des infos de la table resultat Ecrevisse
 522          T_TABL_TMP1 = TABLECR1.EXTR_TABLE()
 523          T_DEB_TMP1  = DEBIECR1.EXTR_TABLE()
 524 #         # On ajoute deux colonnes supplementaires
 525 #         _nb_ligne = len(T_DEB_TMP1["DEBTOT"])
 526 #         T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*_nb_ligne
 527 #         T_DEB_TMP1["INST"]       = [_inst_p_un]*_nb_ligne
 528
 529          # Le calcul Ecrevisse c'est bien passe ?
 530          EcrevisseExe = ( T_TABL_TMP1.values()['COTES'][0] != -1 )
 531          #
 532          if ( not EcrevisseExe ):
 533             # Destruction des concepts de sortie, et on arrete tout
 534             DETRUIRE(
 535                CONCEPT=( _F(NOM=MECAECR1),
 536                          _F(NOM=FLU1ECR1),
 537                          _F(NOM=FLU2ECR1),
 538                          _F(NOM=TABLECR1),
 539                          _F(NOM=DEBIECR1),
 540                ),
 541                INFO=1,ALARME='NON',
 542             )
 543             if ( not IsInit ):
 544                DETRUIRE(
 545                   CONCEPT=( _F(NOM=MECAECR0),
 546                             _F(NOM=FLU1ECR0),
 547                             _F(NOM=FLU2ECR0),
 548                             _F(NOM=TABLECR0),
 549                             _F(NOM=DEBIECR0),
 550                   ),
 551                   INFO=1,ALARME='NON',
 552                )
 553             FinBoucle = True
 554             break
 555          #
 556          # A t'on atteint la convergence
 557          #  TABLECR0 table Ecrevisse a _inst
 558          #  TABLECR1 table Ecrevisse a _inst_p_un
 559          # --------------------
 560
 561          if ( not IsInit ):
 562             # On recupere la liste des temperatures a t et t+1
 563             lst_T_0 = T_TABL_TMP0.values()['TEMP']
 564             lst_T_1 = T_TABL_TMP1.values()['TEMP']
 565             # Le maximum des ecarts
 566             lst_T_diff_01 = []
 567             for v1, v2 in zip(lst_T_0,lst_T_1):
 568                lst_T_diff_01.append(abs(v1-v2))
 569             max_T_diff_01 = max(lst_T_diff_01)
 570
 571             # On recupere la liste des pressions a t et t+1
 572             lst_P_0 = T_TABL_TMP0.values()['PRESSION']
 573             lst_P_1 = T_TABL_TMP1.values()['PRESSION']
 574             # Le maximum des ecarts
 575             lst_P_diff_01 = []
 576             for v1, v2 in zip(lst_P_0,lst_P_1):
 577                lst_P_diff_01.append(abs(v1-v2))
 578             max_P_diff_01 = max(lst_P_diff_01)
 579             #
 580             # "TEMP_PRESS","EXPLICITE","TEMP","PRESS"
 581             ErreurT = (max_T_diff_01/MacrTempRef)
 582             ErreurP = (max_P_diff_01/MacrPresRef)
 583             ErreurG = (ErreurT**2+ErreurP**2)**0.5
 584             if   ( MacrCritere == 'TEMP' ):
 585                Erreur = ErreurT
 586             elif ( MacrCritere == 'PRESS' ):
 587                Erreur = ErreurP
 588             else:
 589                Erreur = ErreurG
 590
 591             if ( MacrCritere != 'EXPLICITE' ):
 592                Convergence = ( Erreur <= MacrPrecisCritere )
 593             #
 594             if info2 :
 595                 # Info Critere
 596                 UTMESS('I', 'ECREVISSE0_35', valr=[_inst_p_un], valk=[MacrCritere,MacrPrecisCritere,Convergence])
 597                 # Info Convergence
 598                 UTMESS('I', 'ECREVISSE0_34', valr=[_inst_p_un,ErreurT,max_T_diff_01,ErreurP,max_P_diff_01,ErreurG])
 599
 600          else:
 601             Convergence = True
 602             if info2 :
 603                 UTMESS('I', 'ECREVISSE0_36', valr=[_inst_p_un])
 604          # --------------------
 605          #
 606
 607
 608          if ( MacrCritere == 'EXPLICITE' ):
 609             Convergence = True
 610          else:
 611             if ( (_nume_ordre != 0) and (_nume_ordre+1 <= MacrNumeOrdre) ):
 612                UTMESS('A','ECREVISSE0_33', vali=[_nume_ordre+1,MacrNumeOrdre],valr=[_inst_p_un])
 613                Convergence = True
 614
 615          if ( Convergence ):
 616             nb_lignes_t1 = len(T_TABL_TMP1["COTES"])
 617             # Ajout de deux colonnes supplementaires
 618             # POUR LA TABLE ECREVISSE
 619             T_TABL_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_lignes_t1
 620             T_TABL_TMP1["INST"]       = [_inst_p_un]*nb_lignes_t1
 621
 622             # POUR LA TABLE DES DEBITS
 623             nb_ligne_t2 = len(T_DEB_TMP1["DEBTOT"])
 624             T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_ligne_t2
 625             T_DEB_TMP1["INST"]       = [_inst_p_un]*nb_ligne_t2
 626
 627             #
 628             # Ajout des infos dans la table finale
 629             if ( IsInit ):
 630                T_TABL_RES = T_TABL_TMP1
 631                T_DEB_RES  = T_DEB_TMP1
 632             else:
 633                T_TABL_RES = merge(T_TABL_RES, T_TABL_TMP1)
 634                T_DEB_RES = merge(T_DEB_RES, T_DEB_TMP1)
 635                T_TABL_RES.titr = 'TABLE_SDASTER CHARGEMENT ECREVISSE'
 636                T_DEB_RES.titr = 'TABLE_SDASTER DEBIT ECREVISSE'
 637             #
 638             # RAZ des compteurs de division
 639             NbIter = 0
 640             # On memorise les concepts valides
 641             MECAECR0 = MECAECR1
 642             FLU1ECR0 = FLU1ECR1
 643             FLU2ECR0 = FLU2ECR1
 644             TABLECR0 = TABLECR1
 645             DEBIECR0 = DEBIECR1
 646             #
 647             T_TABL_TMP0 = T_TABL_TMP1
 648             if (not IsInitEcre) :
 649               IsInit = False
 650             if (info2):
 651               UTMESS('I','ECREVISSE0_37', valr=[_inst_p_un])
 652             break
 653
 654          else:
 655             NbIter += 1
 656             # A t'on le droit de decouper, par rapport au nombre de division
 657             if ( NbIter > MacrNbDecoupage ):
 658                FinBoucle = True
 659                UTMESS('A','ECREVISSE0_30', valr=[_inst,_inst_p_un],vali=[MacrNbDecoupage])
 660                break
 661             #
 662             # on divise le pas de temps par 2
 663             tmp = (_inst + _inst_p_un )*0.5
 664             # A t'on le droit de continuer, par rapport au pas de temps minimum
 665             if ( (tmp - _inst) <= MacrPasMini ):
 666                FinBoucle = True
 667                UTMESS('A','ECREVISSE0_31', valr=[_inst,_inst_p_un,tmp,MacrPasMini])
 668                break
 669             #
 670             if ( info2 ):
 671                UTMESS('A','ECREVISSE0_32', valr=[_inst,_inst_p_un,tmp],vali=[NbIter])
 672             # on insere le nouveau temps dans la liste des instants avant "_inst_p_un"
 673             _liste_inst.insert(_nume_ordre+1,tmp)
 674
 675
 676       # Convergence atteinte, on passe au pas de temps suivant, s'il en reste
 677       if IsInitEcre :
 678          continue
 679       elif (_nume_ordre + 2 < len(_liste_inst)):
 680          _nume_ordre += 1
 681       else:
 682          # On a fait tous les pas de temps
 683          FinBoucle = True
 684    #######################################################################################
 685    #     Fin boucle sur les pas de temps
 686    #######################################################################################
 687
 688    # Creation du concept de la table en sortie
 689    if ( T_TABL_RES != None ):
 690       dprod = T_TABL_RES.dict_CREA_TABLE()
 691       TABL_RES = CREA_TABLE(**dprod)
 692    if ( T_DEB_RES != None ):
 693       debprod = T_DEB_RES.dict_CREA_TABLE()
 694       DEB_RES = CREA_TABLE(**debprod)
 695
 696    # Destruction des concepts temporaires
 697    DETRUIRE(
 698             CONCEPT=( _F(NOM=MECAECR1),
 699                       _F(NOM=FLU1ECR1),
 700                       _F(NOM=FLU2ECR1),
 701                       _F(NOM=TABLECR1),
 702                       _F(NOM=DEBIECR1),
 703             ),
 704             INFO=1,ALARME='NON',
 705    )
 706
 707    if (_nume_ordre != 0 ):
 708        DETRUIRE(
 709                 CONCEPT=( _F(NOM=MECAECR0),
 710                           _F(NOM=FLU1ECR0),
 711                           _F(NOM=FLU2ECR0),
 712                           _F(NOM=TABLECR0),
 713                           _F(NOM=DEBIECR0),
 714                 ),
 715                 INFO=1,ALARME='NON',
 716        )
 717
 718    return ier