#!/bin/sh
#============================================================================
#
#                    Code_Saturne version 1.3
#                    ------------------------
#
#
#     This file is part of the Code_Saturne Kernel, element of the
#     Code_Saturne CFD tool.
#
#     Copyright (C) 1998-2007 EDF S.A., France
#
#     contact: saturne-support@edf.fr
#
#     The Code_Saturne Kernel is free software; you can redistribute it
#     and/or modify it under the terms of the GNU General Public License
#     as published by the Free Software Foundation; either version 2 of
#     the License, or (at your option) any later version.
#
#     The Code_Saturne Kernel is distributed in the hope that it will be
#     useful, but WITHOUT ANY WARRANTY; without even the implied warranty
#     of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#     GNU General Public License for more details.
#
#     You should have received a copy of the GNU General Public License
#     along with the Code_Saturne Kernel; if not, write to the
#     Free Software Foundation, Inc.,
#     51 Franklin St, Fifth Floor,
#     Boston, MA  02110-1301  USA
#
#============================================================================
#
########################################################################
#
# Exemple de fichier de lancement Code_Saturne
#
########################################################################
# TEST_A_ENLEVER_POUR_UTILISER_LE_SOUS_PROGRAMME_DEBUT
#   CE TEST PERMET A L'UTILISATEUR D'ETRE CERTAIN QUE C'EST 
#   BIEN SON LANCE QUI EST UTILISE ET NON CELUI DE LA BIBLIOTHEQUE
  echo ' ' 
  echo ' Attention : ' 
  echo ' ' 
  echo ' Le script de lancement lance utilise est celui de la '
  echo '   bibliotheque : il est inadapte au cas a traiter.' 
  echo ' ' 
  echo ' Pour utiliser le script lance de votre repertoire SCRIPTS '
  echo '   il faut se placer dans ce repertoire et utiliser la commande'
  echo '   ./lance '
  echo ' ' 
  echo ' Si le message '
  echo '   ./lance: cannot execute '
  echo ' est renvoye, il faut rendre le fichier executable comme suit '
  echo '   chmod +x ./lance '
  echo ' ' 
  exit 1
# TEST_A_ENLEVER_POUR_UTILISER_LE_SOUS_PROGRAMME_FIN
########################################################################
#
#                  CARTES BATCH POUR LE CCRT (Nickel/Chrome/Tantale sous LSF)
#                  ==========================================================
#
#BSUB -n 2
#BSUB -W 00:05  
#BSUB -o nometcaso.%J 
#BSUB -e nometcase.%J 
#BSUB -J nometcas
#
#  -n : nombre de processeurs
#  -c : temps limite pour le job (cumul par processeur de tous les process du job)
#       au format hh:mm (heures:minutes)
#  -o : nom du listing de sortie
#  -e : nom du listing d'erreur
#  -J : nom du job
#
#ATTENTION : Les calculs lances sur Tantale sont executes sur Tantale, mais pour
#            Nickel/Chrome, la machine d'execution (Nickel Ou Chrome) est definie
#            par la classe du calcul et pas par la machine qui a execute la commande
#            "bsub". Attention aux disques WORKDIR non partages entre Nickel et
#            Chrome.
#ATTENTION : En cas de couplage avec Syrthes, 1 processeur
#            sera reserve pour chacune des instances de Syrthes,
#            et un processeur pour l'Enveloppe. Le Noyau ne sera
#            execute que sur les processeurs restants.
#            Pensez  reserver un nombre suffisant de processeurs.
#
# ------------------------------------------------------------------
#
#                  CARTES BATCH POUR LE CLUSTER CHATOU sous PBS
#                  ============================================
#
#PBS -l nodes=4:ppn=2,walltime=1:00:00,mem=320mb
#PBS -j eo -N nometcas
#
#  nodes= nombre de "noeuds" a reserver sur le cluster
#  ppn  = nombre de processeurs par noeud (1 ou 2)
#  cput     = cpu time (heures, minutes, secondes)
#  walltime = wall clock time (heures, minutes, secondes)
#  mem  = memoire
#
#ATTENTION : En cas de couplage avec Syrthes, 1 processeur
#            sera reserve pour chacune des instances de Syrthes,
#            et un processeur pour l'Enveloppe. Le Noyau ne sera
#            execute que sur les processeurs restants.
#            Pensez  reserver un nombre suffisant de processeurs.
#
# ------------------------------------------------------------------
#
#                  CARTES BATCH POUR LE CLUSTER de University of Manchester
#                  ========================================================
#
# set the name of the job
##$ -N nometcas
#
# request between 2 and 4 slots
##$ -pe mpich 2-4
#
# Execute the job from the current working directory
# Job output will appear in this directory
##$ -cwd
#   can use -o dirname to redirect stdout
#   can use -e dirname to redirect stderr

#  Export these environment variables
##$ -v MPI_HOME

#set -x
########################################################################
#
# Definition du cas 
#        : rubrique utilisateur
#
# Se reporter au fichier joint "lance.help" pour toute information
#   sur les rubriques a remplir et les valeurs possibles.
#
#
#                    -------------------------------
#
#
#
#                 NE PAS LAISSER DE BLANCS (c'est un script)
#
#
#                    -------------------------------
#
IFOENV=1
LONGIA=1000000
LONGRA=5000000
#
# Sur certaines machines, dont Tantale, des librairies externes
# peuvent necessiter la definition de la variable TERM
export TERM=xterm
#
ETUDE=NOMET
CAS=NOMCAS
PARAM=
MAILLAGE="nomet.unv"
COMMANDE_RC=
COMMANDE_DF=
COMMANDE_PERIO=
COMMANDE_SYRTHES=
DONNEES_THERMOCHIMIE=
#
# Choix du nombre total de processeurs utilises (si vide, detection automatique
# via le systeme de queue si possible, mise a 1 sinon).
# En cas de couplage Syrthes avec MODE_COUPLAGE=MPI, le 1er processeur est
# utilise pour Syrthes, donc le nombre effectif de processeurs dedies au noyau
# est reduit de 1.
# La liste des processeurs n'est utilisable qu'hors systeme de queue
# (un tel systeme fournissant lui-meme une liste equivalente)
NOMBRE_DE_PROCESSEURS=
LISTE_PROCESSEURS=
#
FICHIERS_DONNEES_UTILISATEUR=""
FICHIERS_RESULTATS_UTILISATEUR=""
#
# Repertoire temporaire local (vide pour valeur automatique par defaut)
CS_TMP_PREFIX=
#CS_TMP_PREFIX=/local00/users/`whoami`
#
OPTIMISATION=
LISTE_LIB_SAT=
OPTION_LIB_EXT=
VALGRIND=
#
ARG_CS_VERIF=""
ARG_CS_OUTPUT=""
ECHOCOMM=""
#
#Pilotage du couplage avec HOMARD
PILOTAGE_ADAPTATION=
#
resume=resume
REPBASE=NOMREPBASE
DATA=$REPBASE/DATA
RESU=$REPBASE/RESU
FORT=$REPBASE/FORT
SCRIPTS=$REPBASE/SCRIPTS
SUITE_AMONT=$DATA/SUITE
PRE_TRAITEMENT_AMONT=$DATA/PRE_TRAITEMENT
REPMAIL=$REPBASE/../MAILLAGE
#
# Les variables suivantes ne sont utiles que dans les cas couples avec SYRTHES
#  DATA_SYR : repertoire ou trouver SYRTHES_ENV
#  FORT_SYR : repertoire ou trouver les fichiers utilisateur eventuels
DATA_SYR=$REPBASE/DATA_SYR
SYRTHES_ENV=syrthes.env 
FORT_SYR=$REPBASE/FORT_SYR
#
# Le mode de couplage eventuel avec Syrthes peut etre choisi ici.
# (attention aux majuscules/minuscules).
# Si l'on n'a pas de couplage, cette variable sera mise a zero par la suite.
#
#  MODE_COUPLAGE=MPI     : recommande sur tout cluster (CCRT ou Chatou notamment).
#  MODE_COUPLAGE=sockets : solution de secours sur cluster si l'on ne sait
#                          determiner le rang MPI d'un process a priori
#                          (i.e. si rang_mpi.sh ne peut etre adapte)
#                          ou si l'on ne dispose pas de MPI.
#  MODE_COUPLAGE=pipes   : sur station de travail ou autre machine a memoire
#                          partagee uniquement (les pipes n'etant visibles
#                          que localement, et ne "traversant" pas le reseau).
MODE_COUPLAGE=MPI
#
# On peut utiliser 3 modes d'execution.
# (attention aux minuscules/majuscules)
#
#  MODE_EXEC=complet        : choix par defaut (Enveloppe puis calcul).
#  MODE_EXEC=pre_traitement : lancement de l'Enveloppe seule, pour generer
#                             les fichiers enveloppe_vers_solveur*.
#  MODE_EXEC=calcul         : lancement du calcul seul, en utilisant des
#                             fichiers enveloppe_vers_solveur* deja generes et
#                             accessibles dans le repertoire $PRE_TRAITEMENT_AMONT.
#
MODE_EXEC=complet
#
#
#
#
########################################################################
#
# FIN DE ZONE UTILISATEUR POUR CALCULS STANDARDS
# END OF USER MODIFIABLE ZONE FOR STANDARD CALCULATIONS
#
########################################################################
#
#  Adresse de la bibliotheque du noyau    
CS_HOME=NOMCSHOME
export CS_HOME
#
# Parametres d'installation
#
. $CS_HOME/bin/cs_profile
#
#Verification de la compatibilite de la bibliotheque
if [ ! -f ${CS_HOME}/bin/macros_${NOM_ARCH}.mk ]
then
  echo Architecture ${NOM_ARCH} non supportee par la version de Code_Saturne
  echo ${CS_HOME}
  exit 1
fi
#
########################################################################
#  Adaptation de maillage
#
if [ ! -z  "${PILOTAGE_ADAPTATION}" ] ; then
  if [ "${PILOTAGE_ADAPTATION}" = "-aide" -o "${PILOTAGE_ADAPTATION}" = "-help" ] ; then
    ${CSHOMARD_HOME}/saturne_homard ${PILOTAGE_ADAPTATION}
    exit 0
  else
    Options_HOMARD="  -v"
    ${CSHOMARD_HOME}/saturne_homard -Saturne_Script $0 -Donnees_Calcul $REPBASE \
                    -Pilotage_Adaptation $PILOTAGE_ADAPTATION $Options_HOMARD || exit 1
  fi
fi
#
#########################################################################
#
#
# Determination automatique de IFOENV : on aura 
#   IFOENV = 1 si couplage Syrthes
#   on rajoute alors automatiquement l'option de communication
#   (via MPI, sockets, ou pipes selon la valeur de MODE_COUPLAGE)
#  
#
N_COUPLAGE_SYRTHES=0
N_COUPLAGE_SYRTHES=`echo $COMMANDE_SYRTHES | grep -c syrthes`
if [ $N_COUPLAGE_SYRTHES = 0 ] ; then 
  COUPLAGE_SYRTHES=non
else
  COUPLAGE_SYRTHES=oui
  export SYRTHES
  if [ $N_COUPLAGE_SYRTHES -gt 1 ] ; then
   echo "Ce script ne prend pas en charge plusieurs couplage Syrthes"
   echo "Nombre de couplages Syrthes demande : $N_COUPLAGE_SYRTHES"
  fi
fi
#
if [ $COUPLAGE_SYRTHES = oui ] ; then 
  IFOENV=1
else
  MODE_COUPLAGE=
fi
#
########################################################################
#
# Definition des parametres d'execution
#
#   Variables generales
THISSCRIPT=$0
USER=`whoami`
DATE=`date '+%m%d%H%M'`
SUFFIXE=$DATE
EXE=cs13.exe
EXE_SYR=syrthes
#
# on recopie le script de lancement avant de se positionner dans le
# repertoire de travail (car ensuite, un chemin relatif ne sera
# plus a jour)

cp $0 $RESU/lance.$SUFFIXE
#
#   Repertoire d'execution (accessible depuis tous les procs)
#
if [ ! -z "$CS_TMP_PREFIX" ] ; then
  RUN=${CS_TMP_PREFIX}/tmp_Saturne/$ETUDE.$CAS.$DATE
#
else
#  Valeur par defaut si l'utilisateur n'a rien specifie
#
#  A priori sur Nickel/Chrome, c'est mieux avec TMPDIR, sauf si on veut
#    debuguer (car $TMPDIR est detruit a la fin du job)
  if [ "$NOM_ARCH" = "OSF1" ] ; then
    RUN=$TMPDIR
#   RUN=/scratch/scratchdir/$USER/TMPDIR/$ETUDE.$CAS.$DATE
#
#  Sur Tantale, il n'y a pas de TMPDIR. On met par defaut dans SCRATCHDIR
  elif [ "$NOM_ARCH" = "Linux_CCRT" ] ; then
    RUN=$SCRATCHDIR/tmp_Saturne/$ETUDE.$CAS.$DATE
#
#  Sur l'ancien cluster MFEE, il y a un TMPDIR, mais il correspond
#  a un repertoire local, non partage par les noeuds. On ne peut
#  donc pas l'utiliser
  elif [ "$NOM_ARCH" = "Linux_SCALI" ] ; then
    RUN=$HOME/tmp_Saturne/$ETUDE.$CAS.$DATE
#
#  Sur station classique ou cluster generique, on
#  n'utilisera TMPDIR que s'il est defini
#  (via un systeme batch en general)
  elif [ "$TMPDIR" != "" -a "$TMPDIR" != "/tmp" ] ; then
    RUN=$TMPDIR
  else
    RUN=$HOME/tmp_Saturne/$ETUDE.$CAS.$DATE
  fi
fi
#
# Creation automatique du repertoire si necessaire
if [ "$RUN" != "$TMPDIR" ] ; then
  if [ ! -d $RUN ] ; then
    mkdir -p $RUN || exit 1
  else
    echo "Le repertoire RUN=$RUN existe deja."
    echo "Le calcul ne peut pas etre execute."
    exit 1
  fi
fi
#
cd $RUN
#
########################################################################
#
# Parallelisme
#
# Liste des processeurs
#
if [ -f "$TMPDIR/machines" ] ; then   # avec systeme de queue Manchester
   MPIHOSTS="$TMPDIR/machines"
elif [ ! -z "$PBS_NODEFILE" ] ; then    # avec system de queue PBS
   MPIHOSTS="$PBS_NODEFILE"
elif [ ! -z "$LSB_HOSTS" ] ; then       # avec systeme de queue LSF
   \rm -f $RUN/hostsfile
   echo $LSB_HOSTS | awk '{ for (ii = 1; ii < NF+1; ++ii) print $ii }' >> $RUN/hostsfile
   MPIHOSTS="$RUN/hostsfile"
elif [ ! -z "$LISTE_PROCESSEURS" ] ; then
   \rm -f $RUN/hostsfile
   localproc=`hostname`
   echo $LISTE_PROCESSEURS | grep -q $localproc || LISTE_PROCESSEURS="$localproc & $LISTE_PROCESSEURS"
   echo $LISTE_PROCESSEURS | awk  -F\& '{ for (ii = 1; ii < NF+1; ++ii) print $ii }' >> $RUN/hostsfile
   MPIHOSTS="$RUN/hostsfile"
fi
# Verification du nombre de processeurs
if [ -z  "${NOMBRE_DE_PROCESSEURS}" ] ; then
  if [ ! -z  "${NSLOTS}" ] ; then
    # pour systeme de queue cluster Manchester
    NOMBRE_DE_PROCESSEURS=$NSLOTS
  elif [ ! -z "${SLURM_NPROCS}" ] ; then
    # pour systeme de queue LSF avec Slurm
    NOMBRE_DE_PROCESSEURS=$SLURM_NPROCS
  elif [ ! -z "${LSB_HOSTS}" ] ; then
    # pour systeme de queue LSF sans Slurm
    NOMBRE_DE_PROCESSEURS=`echo $LSB_HOSTS | wc -w`
  elif [ ! -z  "${MPIHOSTS}" ] ; then
    # pour systeme de queue cluster MFEE ou des que MPIHOSTS est defini
    NOMBRE_DE_PROCESSEURS=`cat $MPIHOSTS | wc -l`
  else
    NOMBRE_DE_PROCESSEURS=1
  fi
fi
#
# Verification du nombre de noeuds si possible
NOMBRE_DE_NOEUDS=1
if [ -z  "${NOMBRE_DE_PROCESSEURS}" ] ; then
  if [ ! -z  "${MPIHOSTS}" ] ; then
    NOMBRE_DE_NOEUDS=`sort $MPIHOSTS | sed -e 's/:/ /' | cut -f 1 -d" " | uniq | wc -l`
  fi
fi
#
# Verification du nombre de processeurs demandes
nproc_noy=${NOMBRE_DE_PROCESSEURS}
echo
echo
if [ $COUPLAGE_SYRTHES = oui ] ; then
  echo "Couplage de Code_Saturne avec Syrthes active"
  if [ ! -z "$MPIHOSTS" ] ; then
  #  si on utilise Syrthes en batch par MPI, on lui reserve un processeur par instance
    if [ "$MODE_COUPLAGE" = "MPI" ] ; then
      (( nproc_noy = nproc_noy - N_COUPLAGE_SYRTHES ))
      if [ $nproc_noy -lt 1 ] ; then 
        echo
        echo
        echo " Attention, avec MODE_COUPLAGE = MPI, Syrthes reserve un processeur."
        echo "   Le nombre de processeurs demande ($NOMBRE_DE_PROCESSEURS)"
        echo "   est donc insuffisant."
        echo " Augmenter le nombre de processeurs reserves dans les cartes batch."
        echo
        exit 1
      fi
    fi
  #  si on utilise Syrthes en batch pipe, on verifie que tout tient sur un seul noeud
    if [ "$MODE_COUPLAGE" = "pipes" -a "$NOMBRE_DE_NOEUDS" != 1 ] ; then
      echo
      echo
      echo " Attention, avec MODE_COUPLAGE = pipes, les transmissions  "
      echo "   Syrthes-noyau se font par tubes (pipes). "
      echo " Ici, plusieurs machines ont ete selectionnees pour "
      echo "   realiser le calcul en parallele : "
      cat "$MPIHOSTS"
      echo " Les tubes (pipes) sont limites a un noeud et le calcul "
      echo "   risque de ne pas pouvoir aboutir."
      echo " Utiliser une autre valeur de MODE_COUPLAGE "
      echo
      exit 1
    fi
  else
  #  si on n'est pas en batch et qu'on couple par MPI, on doit specifier un nombre
  #    de processeurs superieur a 1 pour activer MPI
    if [ "$MODE_COUPLAGE" = "MPI" ] ; then
      (( nproc_noy = nproc_noy - N_COUPLAGE_SYRTHES ))
      if [ $nproc_noy -lt 1 ] ; then 
        echo
        echo
        echo " Attention, avec MODE_COUPLAGE = MPI, Syrthes reserve un processeur"
        echo "   (eventuellement virtuel)."
        echo "   Le nombre de processeurs demande ($NOMBRE_DE_PROCESSEURS)"
        echo "   doit donc etre strictement superieur a 1."
        echo " Augmenter NOMBRE_DE_PROCESSEURS."
        echo
        exit 1
      fi
    fi
  #  si on n'est pas en batch et qu'on couple par pipes, on diminue aussi
  #  NOMBRE_DE_PROCESSEURS pour ne pas avoir besoin de MPI si
  #  Code_Saturne et Syrthes tournent chacun sur 1 processeur
    if [ "$MODE_COUPLAGE" = "pipes" ] ; then
      (( nproc_noy = nproc_noy - N_COUPLAGE_SYRTHES ))
      (( NOMBRE_DE_PROCESSEURS = NOMBRE_DE_PROCESSEURS - 1 ))
      if [ $nproc_noy -lt 1 ] ; then 
        echo
        echo
        echo " Attention, avec MODE_COUPLAGE = pipes, Syrthes reserve un processeur"
        echo "   (eventuellement virtuel)."
        echo "   Le nombre de processeurs demande ($NOMBRE_DE_PROCESSEURS)"
        echo "   doit donc etre strictement superieur a 1."
        echo " Augmenter NOMBRE_DE_PROCESSEURS."
        echo
        exit 1
      fi
    fi
  fi
fi
if [ $nproc_noy -gt 1 ] ; then
  echo "Calcul Code_Saturne parallele avec decomposition en $nproc_noy sous-domaines"
  if [ $IFOENV = 0 ] ; then 
    echo
    echo
    echo " Calcul en parallele impossible avec IFOENV = $IFOENV "
    echo " Utiliser IFOENV = 1 "
    echo
    exit 1
  fi
else
  echo "Calcul Code_Saturne monoprocesseur"
fi
if [ ! -z "$MPIHOSTS" ] ; then
  echo "$NOMBRE_DE_PROCESSEURS processeur(s) reserve(s) en tout"
fi
#
# Si le noyau fonctionne en parallele, on doit lui preciser le nombre
# de domaines, ainsi qu'a l'Enveloppe
if [ $nproc_noy -gt 1 ] ; then 
  ARG_ECS_PAR=" -p $nproc_noy"
  ARG_CS_PAR=" -p $nproc_noy"
else
  ARG_ECS_PAR=""
  ARG_CS_PAR=""
fi
#
# Parametres lies au systeme
#
if [ $NOMBRE_DE_PROCESSEURS -gt 1 ] ; then 
#
# Valeurs par defaut definies au depart
  MPIBOOT=""
  MPIHALT=""
  MPIRUN="mpirun -np ${NOMBRE_DE_PROCESSEURS}"
  if [ -d "$CS_MPI_PATH" ] ; then
    export PATH=${CS_MPI_PATH}:$PATH
  fi
#
  if [ "$NOM_ARCH" = "OSF1" ] ; then 
    MPIRUN="prun -n ${NOMBRE_DE_PROCESSEURS} -stv"
#
  elif [ "$NOM_ARCH" = "Linux_CCRT" ] ; then
    MPIRUN="mpirun -srun"
#
  elif [ "$NOM_ARCH" = "Linux_Ch" ] ; then 
    MPIRUN="mpirun -np ${NOMBRE_DE_PROCESSEURS} -machinefile $PBS_NODEFILE"
#
  else 
    if [ -d "$CS_MPI_PATH" ] ; then 
      if [ -f "${CS_MPI_PATH}/mpdboot" ] ; then          # Si MPI de type MPICH2
        MPIBOOT="${CS_MPI_PATH}/mpdboot"
        MPIHALT="${CS_MPI_PATH}/mpdallexit"
        MPIRUN="${CS_MPI_PATH}/mpiexec -n ${NOMBRE_DE_PROCESSEURS}" 
        if [ ! -z "$MPIHOSTS" ] ; then
          MPIBOOT="$MPIBOOT -n ${NOMBRE_DE_NOEUDS} -v -f $MPIHOSTS"
	fi
      elif [ -f "${CS_MPI_PATH}/ompi_info" ] ; then      # Si MPI de type Open MPI
        MPIRUN="${CS_MPI_PATH}/mpiexec -n ${NOMBRE_DE_PROCESSEURS}" 
        if [ ! -z "$MPIHOSTS" ] ; then
          MPIRUN="$MPIRUN -machinefile $MPIHOSTS"
        fi
      elif [ -f "${CS_MPI_PATH}/lamboot" ] ; then        # Si MPI de type LAM MPI
        MPIBOOT="${CS_MPI_PATH}/lamboot"
        MPIHALT="${CS_MPI_PATH}/lamhalt"
        MPIRUN="${CS_MPI_PATH}/mpirun -np ${NOMBRE_DE_PROCESSEURS}" 
        if [ ! -z "$MPIHOSTS" ] ; then
          MPIBOOT="$MPIBOOT -v $MPIHOSTS"
          MPIHALT="$MPIHALT -v $MPIHOSTS"
        fi
      elif [ -f "${CS_MPI_PATH}/mpichversion" ] ; then   # Si MPI de type MPICH
        MPIRUN="${CS_MPI_PATH}/mpirun -np ${NOMBRE_DE_PROCESSEURS}" 
        if [ ! -z "$TMPDIR/machines" ] ; then   # avec systeme de queue Manchester
          MPIRUN="$MPIRUN -machinefile $TMPDIR/machines"
        elif [ ! -z "$MPIHOSTS" ] ; then
          MPIRUN="$MPIRUN -machinefile $MPIHOSTS"
        fi
      fi
    fi
  fi
#
#   si on ne demande pas plusieurs processeurs
#
else
#
  MPIRUN=""
  MPIBOOT=""
  MPIHALT=""
fi
#
########################################################################
#
# Communications
#
# Definition des sockets
if [ $COUPLAGE_SYRTHES = oui -a "$MODE_COUPLAGE" = "sockets" ] ; then
  SOCKETSYR="-comm-socket"
else
  SOCKETSYR=""
fi
# En prevision des echo comm si probleme
if [ ! -z "$ECHOCOMM" ] ; then 
  ECHOCOMMNB="$ECHOCOMM"
  ECHOCOMMECS="-echo-comm $ECHOCOMMNB"
  ECHOCOMMSYR="-echo-comm $ECHOCOMMNB"
  ECHOCOMMNOY="--echo-comm $ECHOCOMMNB"
else
  ECHOCOMMNB=""
  ECHOCOMMECS=""
  ECHOCOMMSYR=""
  ECHOCOMMNOY=""
fi
########################################################################
#
# Mode verification
# (on active par defaut le voisinage etendu)
#
if [ ! -z "$ARG_CS_VERIF" ] ; then
  ARG_CS_VERIF="-v $ARG_CS_VERIF"
fi
########################################################################
# Message d'accueil 
#
echo ' '
echo '                       Execution de Code_Saturne '
echo '                       ************************* '
echo ' '
echo ' Repertoire de travail (penser a le purger periodiquement) : ' 
echo '    ' $RUN
#
########################################################################

# Fonction de reperage d'un sous programme utilisateur
#  pour le moment, on fait simple 
#   (on pourrait verifier que uslag2 contient bien uslag2 ou encore 
#   qu'il n'est pas bidon ...) 
presence () {

  presence_sspgm=$1

  if [ ! -f "${presence_sspgm}" ] ; then
    presence_PRESENT="non"
  else
    presence_PRESENT="oui"
  fi
  echo ${presence_PRESENT} 
}
#
########################################################################
#
# Compilation et edition des liens
#
# Remarque : on en profite pour reperer la presence de certains 
#            sous-programmes utilisateurs.
#
if [ "$CS_HOME" = "" ]; then
   echo
   echo "WARNING: la variable CS_HOME n est pas positionnee"
   echo
   exit 1
else
  echo
  echo ' Version noyau :      ' $CS_HOME
  echo ' Version enveloppe :  ' $ECS_HOME
fi

source_cas=$FORT

if [ -f compil.log ] ; then
  rm -f compil.log
fi

if [ $MODE_EXEC != pre_traitement ] ; then

  echo
  echo  "  *****************************************************************************"
  echo  "   Compilation des sous-programmes utilisateur et edition de liens Code_Saturne"
  echo  "  *****************************************************************************"

  cur_dir=`pwd`

  # Determination de la version des compilateurs 
  ${CS_HOME}/bin/compiler_version -cshome ${CS_HOME} -nomarch ${NOM_ARCH} -output ${cur_dir}/compil.log

  # Recopie des sources utilisateur 
  #  (pas de liens : on recopie le repertoire ensuite)
  mkdir fort_saturne
  cd fort_saturne
  for fich in ${source_cas}/*.[F,c,h] ; do 
    if [ -f $fich ] ; then
      cp ${fich} .
    fi
  done

# Detection de la presence de modules

# Standard
  USCLIM_PRESENT=`presence "usclim.F"`

# Lagrangien
  USLAG2_PRESENT=`presence "uslag2.F"`

# Rayonnement
  USRAY2_PRESENT=`presence "usray2.F"`

# Charbon pulverise
  USCPCL_PRESENT=`presence "uscpcl.F"`

# Combustion gaz chimie 3 points
  USD3PC_PRESENT=`presence "usd3pc.F"`

# Combustion gaz EBU
  USEBUC_PRESENT=`presence "usebuc.F"`

# Combustion gaz LWC
  USLWCC_PRESENT=`presence "uslwcc.F"`

# Electrique
  USELCL_PRESENT=`presence "uselcl.F"`

# Compressible
  USCFCL_PRESENT=`presence "uscfcl.F"`

# Tests de compatibilite
  if [ "${USCPCL_PRESENT}" = "oui" ] ; then
    if [ "${USCLIM_PRESENT}" = "oui" ] ; then
      echo ' '
      echo ' -- ERREUR -- '
      echo ' Lorsque uscpcl est complete, usclim ne doit pas l etre'
      echo '  (modele combustion charbon pulverise)                '
      echo '  Les conditions aux limites sont fournies dans uscpcl.'
      echo ' '
	exit 1
    fi
  fi
  if [ "${USD3PC_PRESENT}" = "oui" ] ; then
    if [ "${USCLIM_PRESENT}" = "oui" ] ; then
      echo ' '
      echo ' -- ERREUR -- '
      echo ' Lorsque usd3pc est complete, usclim ne doit pas l etre'
      echo '  (modele combustion chimie trois points)              '
      echo '  Les conditions aux limites sont fournies dans usd3pc.'
      echo ' '
	exit 1
    fi
  fi
  if [ "${USEBUC_PRESENT}" = "oui" ] ; then
    if [ "${USCLIM_PRESENT}" = "oui" ] ; then
      echo ' '
      echo ' -- ERREUR -- '
      echo ' Lorsque usebuc est complete, usclim ne doit pas l etre'
      echo '  (modele combustion EBU)                              '
      echo '  Les conditions aux limites sont fournies dans usebuc.'
      echo ' '
	exit 1
    fi
  fi
  if [ "${USLWCC_PRESENT}" = "oui" ] ; then
    if [ "${USCLIM_PRESENT}" = "oui" ] ; then
      echo ' '
      echo ' -- ERREUR -- '
      echo ' Lorsque uslwcc est complete, usclim ne doit pas l etre'
      echo '  (modele combustion LWC)                              '
      echo '  Les conditions aux limites sont fournies dans uslwcc.'
      echo ' '
	exit 1
    fi
  fi
  if [ "${USELCL_PRESENT}" = "oui" ] ; then
    if [ "${USCLIM_PRESENT}" = "oui" ] ; then
      echo ' '
      echo ' -- ERREUR -- '
      echo ' Lorsque uselcl est complete, usclim ne doit pas l etre'
      echo '  (modele electrique)                                  '
      echo '  Les conditions aux limites sont fournies dans uselcl.'
      echo ' '
	exit 1
    fi
  fi

  if [ "${USCFCL_PRESENT}" = "oui" ] ; then
    if [ "${USCLIM_PRESENT}" = "oui" ] ; then
      echo ' '
      echo ' -- ERREUR -- '
      echo ' Lorsque uscfcl est complete, usclim ne doit pas l etre'
      echo '  (modele compressible)                                  '
      echo '  Les conditions aux limites sont fournies dans uscfcl.'
      echo ' '
	exit 1
    fi
  fi

# Traduction 
  if [ "${USLAG2_PRESENT}" = "oui" ] ; then
    LAGRANGIEN=oui
    echo ' '
    echo ' Utilisation du module lagrangien '  
    echo ' '
  else
    LAGRANGIEN=non
  fi
  if [ "${USRAY2_PRESENT}" = "oui" ] ; then
    RAYONNEMENT=oui
    echo ' '
    echo ' Utilisation du module rayonnement '  
    echo ' '
  else
    RAYONNEMENT=non
  fi
  COMBUSTION=non
  if [ "${USCPCL_PRESENT}" = "oui" ] ; then
    COMBUSTION=oui
    COMBUSTION_CPP=oui
    echo ' '
    echo ' Utilisation du module combustion charbon pulverise '  
    echo ' '
  else
    COMBUSTION_CPP=non
  fi
  if [ "${USD3PC_PRESENT}" = "oui" ] ; then
    COMBUSTION=oui
    COMBUSTION_C3P=oui
    echo ' '
    echo ' Utilisation du module combustion chimie trois points '  
    echo ' '
  else
    COMBUSTION_C3P=non
  fi
  if [ "${USEBUC_PRESENT}" = "oui" ] ; then
    COMBUSTION=oui
    COMBUSTION_EBU=oui
    echo ' '
    echo ' Utilisation du module combustion EBU '  
    echo ' '
  else
    COMBUSTION_EBU=non
  fi
  if [ "${USLWCC_PRESENT}" = "oui" ] ; then
    COMBUSTION=oui
    COMBUSTION_LWC=oui
    echo ' '
    echo ' Utilisation du module combustion LWC '  
    echo ' '
  else
    COMBUSTION_LWC=non
  fi
  if [ "${USELCL_PRESENT}" = "oui" ] ; then
    ELECTRIQUE=oui
    echo ' '
    echo ' Utilisation du module electrique '  
    echo ' '
  else
    ELECTRIQUE=non
  fi

  if [ "${USCFCL_PRESENT}" = "oui" ] ; then
    COMPRESSIBLE=oui
    echo ' '
    echo ' Utilisation du module compressible '  
    echo ' '
  else
    COMPRESSIBLE=non
  fi

# Pas de lagrangien en parallele
  if [ "${LAGRANGIEN}" = "oui" ] ; then 
    if [ ${nproc_noy} -gt 1 ] ; then 
      echo ' '
      echo ' -- ERREUR -- '
      echo ' Le mode parallele est incompatible avec le module Lagrangien'
      echo '  dans la version courante.                          '
      echo ' '
	exit 1
    fi
  fi
#
fi # MODE_EXEC != pre_traitement
#
# Avec moindres carres sur voisinage etendu ou modele LES dynamique
# on a besoin du voisinage etendu
# On regarde d'abord le fichier param et on ecrase eventuellement
# le resultat en regardant usini1.F (qui fait reference).
# On utilise des fichiers et pas des variables car la valeur des variables
# changee dans les boucles "while read line" n'est pas recuperee apres le "done"
# Dans le cas du mode de verification, on passe par defaut le voisinage etendu
# (meme si tous les modes ne le necessitent pas forcement).
COMMANDE_VOISET=""
if [ ! -z "$ARG_CS_VERIF" ] ; then
  COMMANDE_VOISET="-ve"
fi
if [ "${COMMANDE_VOISET}" = "" ] ; then 
  fictmpvoiset1=.usini1.F.fichier_temporaire_de_recherche_commande_voiset1
  fictmpvoiset2=.usini1.F.fichier_temporaire_de_recherche_commande_voiset2
  if [ -f $fictmpvoiset1 ] ; then 
    echo le fichier $fictmpvoiset1 existe : arret
    exit 1
  fi      
  if [ -f $fictmpvoiset2 ] ; then 
    echo le fichier $fictmpvoiset2 existe : arret
    exit 1
  fi  
  nturb=0
  ngrad=0
  if [ ! -z "$PARAM" ] ; then
    if [ -f $DATA/$PARAM ] ; then
      ngrad=`grep "gradient_reconstruction choice" $DATA/$PARAM |grep -e "2" -e "3" |wc -l`
      nturb=`grep "turbulence model" $DATA/$PARAM |grep "LES_dynamique" |wc -l`
    fi
    if [ $ngrad -eq 1 ] ; then
      touch $fictmpvoiset1
    fi
    if [ $nturb -eq 1 ] ; then
      touch $fictmpvoiset2
    fi
  fi
  if [ -f usini1.F ] ; then
    grep -i IMRGRA usini1.F | while read line ; do 
      lineupper=`echo $line | tr "[:lower:]" "[:upper:]"`
      firstchar=`echo $lineupper | cut -c1-1`
      if [ "${firstchar}" != "C" ] ; then 
        lineupperwoblank=`echo $lineupper | sed "s/ //g" | sed "s/	//g"`
        if [ "${lineupperwoblank}" = "IMRGRA=2" -o \
             "${lineupperwoblank}" = "IMRGRA=3" ] ; then 
          touch $fictmpvoiset1
        else
          [ -f $fictmpvoiset1 ] && rm -f $fictmpvoiset1
        fi
      fi
    done
    grep -i 'ITURB' usini1.F | grep "=" | while read line ; do
      lineupper=`echo $line | tr "[:lower:]" "[:upper:]"`
      firstchar=`echo $lineupper | cut -c1-1`
      if [ "${firstchar}" != "C" ] ; then 
        lineupperwoblank=`echo $lineupper | sed "s/ //g" | sed "s/	//g" | cut -f2 -d"="`
        if [ "${lineupperwoblank}" = "41" ] ; then
          touch $fictmpvoiset2
        else
          [ -f $fictmpvoiset2 ] && rm -f $fictmpvoiset2
        fi
      fi
    done  
  fi
  if [ -f $fictmpvoiset1 -o -f $fictmpvoiset2 ] ; then
    COMMANDE_VOISET="-ve"
    [ -f $fictmpvoiset1 ] && rm -f $fictmpvoiset1
    [ -f $fictmpvoiset2 ] && rm -f $fictmpvoiset2
  fi
fi
#
if [ $MODE_EXEC != pre_traitement ] ; then

  # Extraction du main sur HP (link avec f90) sauf s'il existe deja
  # (devrait etre migre vers le Makefile si possible)
  if [ "${NOM_ARCH}" = "HP-UX" ] ; then 
    cheminlib=${CS_HOME}/lib/${NOM_ARCH}
    main=cs_main
    mainc=cs_main.c
    maino=cs_main.o
    if [ ! -f "$mainc" ] ; then 
      libsaturneBASE=libsaturneBASE
      if [ ! -z  "${LISTE_LIB_SAT}" ] ; then 
        for module in ${LISTE_LIB_SAT} ; do 
          if [ `echo ${module} | grep ${libsaturneBASE}` ] ; then 
            ar -xv $cheminlib/${libsaturneBASE}${OPTIMISATION} $maino
          fi
        done 
      else
        ar -xv $cheminlib/${libsaturneBASE}${OPTIMISATION}.a  $maino
      fi 
    fi 
  fi

# Compilation
  ln -s ${CS_HOME}/bin/Makefile .

  make saturne OPT="${OPTIMISATION}" LIB="${LISTE_LIB_SAT}" OPTLIBS="${OPTION_LIB_EXT}"  2>>$cur_dir/compil.log 1>&2
  if [ $? -ne 0 ]
  then
    cp $cur_dir/compil.log $RESU/compil.log.$SUFFIXE
    echo ERREUR DE COMPILATION OU D\'EDITION DE LIENS
    rm -f *.o
    exit 1
  else
    cp $cur_dir/compil.log $RESU/compil.log.$SUFFIXE
  fi

# Nettoyage
  make clean
  mv $EXE ${cur_dir}/
  cd ${cur_dir}

  if [ $COUPLAGE_SYRTHES = oui ] ; then 

    echo
    echo  "  *****************************************************************************"
    echo  "    Compilation des sous-programmes utilisateur et edition de liens SYRTHES    "
    echo  "  *****************************************************************************"

    cur_dir=`pwd`
    mkdir fort_syrthes 
    cd fort_syrthes
    for fich in $FORT_SYR/*.[F,c,h] ; do 
      cp ${fich} .
    done
    ln -s $SYRCS_HOME/bin/Makefile .
    make syrthes NOM_ARCH=${NOM_ARCH} 2>>$cur_dir/compil.log 1>&2
    if [ $? -ne 0 ]
    then
      cp $cur_dir/compil.log $RESU/compil.log.$SUFFIXE
      echo ERREUR DE COMPILATION OU D\'EDITION DE LIENS
      rm -f *.o
      exit 1
    else
      cp $cur_dir/compil.log $RESU/compil.log.$SUFFIXE
    fi
    make clean
    mv syrthes $cur_dir/
    cd $cur_dir

  fi

fi # MODE_EXEC != pre_traitement

#
########################################################################
#
# Mise en place des donnees
#
echo
echo  "  ********************************************"
echo  "             Preparation du calcul            "
echo  "  ********************************************"
echo 
if [ $IFOENV = 0 ]
then
  ln -s $REPMAIL/$MAILLAGE geomet || exit 1
elif [ $MODE_EXEC != calcul ]
then
  for var in $MAILLAGE ; do
    ln -s $REPMAIL/$var $var || exit 1
#   cas particulier des maillages au format EnSight : lien sur le fichier .geo 
#   necessaire (recuperation du nom de fichier dans le fichier .case)
    var2=`basename $var .case`
    if [ $var2 != $var ] ; then
      ficgeo_ensight=`awk '/^model:/ {print $2}' $var`
      ln -s $REPMAIL/$ficgeo_ensight $ficgeo_ensight || FIN
    fi
  done
elif [ $MODE_EXEC = calcul ]
then
  for var in ${PRE_TRAITEMENT_AMONT}/* ; do 
    ln -s $var . || exit 1
  done
fi
#
if [ $MODE_EXEC != pre_traitement ] ; then

  for var in ${SUITE_AMONT}/* ; do 
    if [ -f $var ] ; then 
      varb=`basename $var`
      if   [ $varb = suiava ] ; then 
        vara=suiamo
      elif [ $varb = suiavx ] ; then 
        vara=suiamx
      elif [ $varb = vorava ] ; then 
        vara=voramo
      elif [ $varb = t1dava ] ; then 
        vara=t1damo
      elif [ $varb = rayava ] ; then 
        vara=rayamo
      elif [ $varb = lagava ] ; then 
        vara=lagamo
      elif [ $varb = lasava ] ; then 
        vara=lasamo
      else
        vara=$varb
      fi
      ln -s $var $vara
    fi
  done
  #
  if [ "${COMBUSTION}" = "oui" -o "${ELECTRIQUE}" = "oui" ] ; then 
    var=$DATA/$DONNEES_THERMOCHIMIE
    if [ -f $var ] ; then 
      cp $var dp_tch
  # recopie pour avoir le bon nom a la sauvegarde
      if [ "$DONNEES_THERMOCHIMIE" != "dp_tch" ] ; then 
        cp dp_tch $DONNEES_THERMOCHIMIE
      fi
    else
      echo ' ' 
      echo ' -- ERREUR -- ' 
      echo ' Le fichier de donnees thermochimie ' $var
      echo '   n est pas accessible ' 
      exit 1
    fi    
    if [ "${COMBUSTION}" = "oui" ] ; then 
      cp $CS_HOME/data/thch/JANAF JANAF
    fi
  fi
  #
  if [ $COUPLAGE_SYRTHES = oui ] ; then 
    #
    cp $DATA_SYR/$SYRTHES_ENV  .
    #
    # On extrait les informations de syrthes.env et on le modifie en csq 
    #   (tous les fichiers seront locaux)
    # On sauve le fichier auparavant pour pouvoir le recopier avec
    #   les resultats ensuite
    #
    cp $SYRTHES_ENV  $SYRTHES_ENV.save
    #
    AMONT_SYR=`grep "AMONT :" $SYRTHES_ENV | awk -F: '{print $NF}' | sed -e "s/ //g"` 
    AVAL_SYR=` grep "AVAL :"  $SYRTHES_ENV | awk -F: '{print $NF}' | sed -e "s/ //g"`
    SUITE_SYR=`grep "SUITE :" $SYRTHES_ENV | awk -F: '{print $NF}' | sed -e "s/ //g"`
    SYRTHES_DATA=`grep "DONNEES DU CALCUL :" $SYRTHES_ENV | awk -F: '{print $NF}'`
    SYRTHES_GEOM=`grep "GEOMETRIE SOLIDE :" $SYRTHES_ENV | awk -F: '{print $NF}'`
    SYRTHES_SUIT=`grep "SUITE SOLIDE RESU :" $SYRTHES_ENV | awk -F: '{print $NF}'`
    SYRTHES_DATA_RAY=`grep "DONNEES POUR LE RAYONNEMENT :" $SYRTHES_ENV | awk -F: '{print $NF}'`
    SYRTHES_MAIL_RAY=`grep "MAILLAGE RAYONNEMENT :" $SYRTHES_ENV | awk -F: '{print $NF}'`
    SYRTHES_CORR=`grep "STOCKAGE DES CORRESPONDANTS :" $SYRTHES_ENV | awk -F: '{print $NF}'`
    SYRTHES_FFOR_RAY=`grep "FACTEURS DE FORME RAYONNEMENT :" $SYRTHES_ENV | awk -F: '{print $NF}'`
    SYRTHES_CORR_RAY=`grep "STOCKAGE DES CORRESPONDANTS RAYONNEMENT :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_RES1=`grep "RESU SYRTHES 1 :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_RES2=`grep "RESU SYRTHES 2 :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_CHR2=`grep "CHRONO SYRTHES 2 :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_HIST=`grep "HISTORIQUE SOLIDE RESULTAT :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_MAIL_PEAU_FLUIDE=`grep "MAILLAGE PEAU FLUIDE :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_RESU_PEAU_FLUIDE=`grep "RESULTATS PEAU FLUIDE :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_CHR_PEAU_FLUIDE=`grep "CHRONO PEAU FLUIDE :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_MAIL_RAY=`grep "MAILLAGE DE RAYONNEMENT :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_RESU_RAY=`grep "RESULTATS DE RAYONNEMENT :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_CHR_RAY=`grep "CHRONO DE RAYONNEMENT :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    SYRTHES_AVAL_HIST_RAY=`grep "HISTORIQUE RAYONNEMENT :" $SYRTHES_ENV | awk -F: '{print $NF}'`   
    sed -e "s/:.*\//: /"              $SYRTHES_ENV > $SYRTHES_ENV.mod ; mv -f $SYRTHES_ENV.mod $SYRTHES_ENV
    sed -e "s/AMONT :.*/AMONT : .\//" $SYRTHES_ENV > $SYRTHES_ENV.mod ; mv -f $SYRTHES_ENV.mod $SYRTHES_ENV
    sed -e "s/AVAL :.*/AVAL : .\//"   $SYRTHES_ENV > $SYRTHES_ENV.mod ; mv -f $SYRTHES_ENV.mod $SYRTHES_ENV
    sed -e "s/SUITE :.*/SUITE : .\//" $SYRTHES_ENV > $SYRTHES_ENV.mod ; mv -f $SYRTHES_ENV.mod $SYRTHES_ENV
    #
    # si vide, on prend les noms par defaut pour les resultats  : 
    if [ -z "$SYRTHES_CORR" ] ; then 
      SYRTHES_CORR="corresp"
    fi
    if [ -z "$SYRTHES_CORR_RAY" ] ; then 
      SYRTHES_CORR_RAY="corresp_ray"
    fi 
    if [ -z "$SYRTHES_FFOR_RAY" ] ; then 
      SYRTHES_FFOR_RAY="fdf_ray"
    fi 
    if [ -z "$SYRTHES_AVAL_RES1" ] ; then 
      SYRTHES_AVAL_RES1="geoms"
    fi 
    if [ -z "$SYRTHES_AVAL_RES2" ] ; then 
      SYRTHES_AVAL_RES2="resus"
    fi 
    if [ -z "$SYRTHES_AVAL_CHR2" ] ; then 
      SYRTHES_AVAL_CHR2="chronos"
    fi  
    if [ -z "$SYRTHES_AVAL_HIST" ] ; then 
      SYRTHES_AVAL_HIST="histos"
    fi 
    if [ -z "$SYRTHES_AVAL_MAIL_PEAU_FLUIDE" ] ; then 
      SYRTHES_AVAL_MAIL_PEAU_FLUIDE="geomf_ef"
    fi 
    if [ -z "$SYRTHES_AVAL_RESU_PEAU_FLUIDE" ] ; then 
      SYRTHES_AVAL_RESU_PEAU_FLUIDE="resuf_ef"
    fi 
    if [ -z "$SYRTHES_AVAL_CHR_PEAU_FLUIDE" ] ; then 
      SYRTHES_AVAL_CHR_PEAU_FLUIDE="chronof_ef"
    fi 
    if [ -z "$SYRTHES_AVAL_MAIL_RAY" ] ; then 
      SYRTHES_AVAL_MAIL_RAY="resu_ray.geom"
    fi 
    if [ -z "$SYRTHES_AVAL_RESU_RAY" ] ; then 
      SYRTHES_AVAL_RESU_RAY="resu_ray"
    fi 
    if [ -z "$SYRTHES_AVAL_CHR_RAY" ] ; then 
      SYRTHES_AVAL_CHR_RAY="chrono_ray"
    fi 
    if [ -z "$SYRTHES_AVAL_HIST_RAY" ] ; then 
      SYRTHES_AVAL_HIST_RAY="histor"
    fi 
    #
    #
    # On transfere les fichiers syrthes
    #
    for var in $SYRTHES_DATA $SYRTHES_GEOM $SYRTHES_SUIT $SYRTHES_DATA_RAY $SYRTHES_MAIL_RAY ; do 
      cp $AMONT_SYR/$var $RUN/`echo $var | sed -e "s/.*\///"`
    done
    for var in $SYRTHES_CORR $SYRTHES_FFOR_RAY $SYRTHES_CORR_RAY ; do 
      cp $SUITE_SYR/$var $RUN/`echo $var | sed -e "s/.*\///"`
    done
    #
  fi
  #
  if [ ! -z "$FICHIERS_DONNEES_UTILISATEUR" ] ; then 
    for fich in $FICHIERS_DONNEES_UTILISATEUR ; do 
      cp $DATA/$fich .
    done
  fi
  #
  if [ ! -z "$PARAM" ] ; then 
    var=$DATA/$PARAM
    if [ -f $var ] ; then 
      COMMANDE_PARAM="-param $PARAM"
      cp $var .
    else
      echo ' ' 
      echo ' -- ERREUR -- ' 
      echo ' Le fichier de donnees parametrique ' $var
      echo '   n est pas accessible ' 
      exit 1
    fi
  fi
  #
fi # MODE_EXEC != pre_traitement

########################################################################
# Temps limite pour PBS (on le fait ici pour laisser le temps a PBS
#   de se rendre compte que ca a demarre)
#
if [ "$PBS_JOBID" != "" ] ; then 
  CS_MAXTIME=`qstat -r $PBS_JOBID | grep $PBS_JOBID | sed -e's/ \{1,\}/ /g' | cut -d ' ' -f 9`
  export CS_MAXTIME   
fi
#
########################################################################
#
# Resume : debut
#
echo '========================================================'>>$resume
echo '    DATE DE DEBUT   : ' $DATE                            >>$resume
echo '  ----------------------------------------------------'  >>$resume
echo '    CS_HOME         : ' $CS_HOME                         >>$resume
echo '    ECS_HOME        : ' $ECS_HOME                        >>$resume
echo '    ------------------------------------------------  '  >>$resume
cat  $CS_HOME/bin/cs_profile                                   >>$resume
echo '  ----------------------------------------------------'  >>$resume
echo '    UTILISATEUR     : ' $USER                            >>$resume
echo '    ARCHITECTURE    : ' $NOM_ARCH                        >>$resume
echo '========================================================'>>$resume
echo '    MACHINE         : '                                  >>$resume
     uname -a                                                  >>$resume
if [ -z "$NOMBRE_DE_PROCESSEURS" ] ; then 
  echo '    N PROCS         : ' 1                              >>$resume
else
  echo '    N PROCS         : ' $NOMBRE_DE_PROCESSEURS         >>$resume
fi
if [ -z "$LISTE_PROCESSEURS" ] ; then 
  echo '    PROCESSEURS     : ' par defaut                     >>$resume
else
  echo '    PROCESSEURS     : ' $NOMBRE_DE_PROCESSEURS         >>$resume
fi
echo '========================================================'>>$resume
echo '  ----------------------------------------------------'  >>$resume
echo '    CAS             : ' $CAS                             >>$resume
echo '      CONFIG.       : ' $CONF                            >>$resume
echo '        DATA        : ' $DATA                            >>$resume
echo '        FORT        : ' $FORT                            >>$resume
echo '        RESU        : ' $RESU                            >>$resume
echo '  ----------------------------------------------------'  >>$resume
echo '    REP. RUN        : ' $RUN                             >>$resume
echo '  ----------------------------------------------------'  >>$resume
echo '    EXECUTABLE      : ' $EXE                             >>$resume
echo '      BIB           : ' $BIB                             >>$resume
echo '      COMPILATEUR f : ' $COMPF                           >>$resume
echo '      COMPILATEUR c : ' $COMPC                           >>$resume
echo '      OPTIONS     f : ' $OPTCOMPF1                       >>$resume
echo '  ----------------------------------------------------'  >>$resume
#
# Execution 
echo
echo  "  ********************************************"
echo  "                    Execution                 "
echo  "  ********************************************"
echo 
#
ERROR=$RUN/error
erreur()
{
echo ERREUR $1 >> $ERROR
}
#
# Preparation supplementaire pour le couplage Syrthes
#
if [ $COUPLAGE_SYRTHES = oui ] ; then
  #
  if [ "$MODE_COUPLAGE" = "pipes" ] ; then
    #
    # Creation des pipes si besoin
    #
    if [ $nproc_noy -gt 1 ] ; then 
      num=1
      while [ $num -le $nproc_noy ] ; do 
        numf=`echo $num | awk '{printf "%4.4i\n", $1}'`
        for fich in solveur_n${numf}_vers_syrthes.0001 syrthes_vers_solveur_n$numf.0001 ; do
          if [ -f $fich ] ; then
            rm -f $fich
          fi
          mkfifo $fich
        done
        (( num = num + 1 ))
      done
    else
      for fich in solveur_vers_syrthes.0001 syrthes_vers_solveur.0001 ; do
        if [ -f $fich ] ; then 
          rm -f $fich
        fi
        mkfifo $fich
      done
    fi
    #
  # Si sockets, on doit adapter la COMMANDE_SYRTHES 
  #   (on ajoute -socket apres -syrthes)
  #
  elif [ "$MODE_COUPLAGE" = "sockets" ] ; then
    cmdsyr=""
    if [ ! -z "$COMMANDE_SYRTHES" ] ; then 
      for var in $COMMANDE_SYRTHES ; do 
        if [ "$var" = "-syrthes" ] ; then 
          cmdsyr="$cmdsyr $var -socket"
        else 
          cmdsyr="$cmdsyr $var" 
        fi 
      done
      COMMANDE_SYRTHES="$cmdsyr"
    fi
  fi
  #
fi
#
# Lancement de l'Enveloppe pour le pre-traitement
#
if [ $IFOENV = 1 -a $MODE_EXEC != calcul ] ; then
  #
  ${ECS_HOME}/bin/ecs $ARG_ECS_PAR -maillage $MAILLAGE -cas $CAS \
                      $COMMANDE_VOISET \
                      $ECHOCOMMECS \
                      $COMMANDE_RC $COMMANDE_DF $COMMANDE_PERIO > listenv 2>&1 \
                   || erreur " A L'EXECUTION DE L'ENVELOPPE"
  #
  if [ $MODE_EXEC = pre_traitement ] ; then
    #
    PRE_TRAITEMENT_AVAL=$RESU/PRE_TRAITEMENT.$SUFFIXE
    iok=1
    mkdir ${PRE_TRAITEMENT_AVAL} || iok=0
    if [ $iok = 1 ] ; then 
      for fich in enveloppe_vers_solveur* ; do 
        cp $fich ${PRE_TRAITEMENT_AVAL}
      done
    fi
  fi
#
fi
#
# Lancement du calcul proprement dit
#
if [ ! -f $ERROR -a $MODE_EXEC != pre_traitement ] ; then
#
  if [ $COUPLAGE_SYRTHES = oui -a "$MODE_COUPLAGE" = "MPI" ] ; then
    # Communication par MPI
    #
    # Attention a bien transmettre les eventuels arguments supplementaires
    # fournis par mpirun a l'executable (pour le cas de MPICH 1.2 standard, qui
    # fournit les parametres de MPI_Init via argc/argv) : on utilise donc $@
    # pour transmettre les arguments fournis a localexec aux exectables appeles
    #
    localexec=$RUN/localexec
    echo '#!/bin/sh' > $localexec
    echo "MPI_RANK=\`$CS_HOME/bin/rang_mpi.sh \$@\`" >> $localexec
    echo cd $RUN >> $localexec 
    echo "if [ \$MPI_RANK -eq 0 ] ; then" >> $localexec
    echo "  $RUN/$EXE_SYR \$@ -comm-mpi 1 -nbr_sat $nproc_noy $ECHOCOMMSYR > listsyr 2>&1" >> $localexec
    echo "else" >> $localexec
    echo "  $VALGRIND $RUN/$EXE \$@ $ARG_CS_PAR $COMMANDE_SYRTHES -proc 0 "\
         "$ARG_CS_VERIF $ARG_CS_OUTPUT $ECHOCOMMNOY -longia $LONGIA -longra $LONGRA "\
         "$COMMANDE_PARAM " >> $localexec 
    echo "fi" >> $localexec
    echo "retour=\$?" >> $localexec
    echo "exit \$retour" >> $localexec
    chmod 700 $localexec
    #
    $MPIBOOT
    $MPIRUN $localexec || erreur " A L'EXECUTION DU NOYAU "
    $MPIHALT
    #
  elif [ $COUPLAGE_SYRTHES = oui  ] ; then
    # Communication par pipes ou sockets
    #
    # Lancement de saturne
    # Attention a bien transmettre les eventuels arguments supplementaires
    # fournis par mpirun a l'executable (pour le cas de MPICH 1.2 standard, qui
    # fournit les parametres de MPI_Init via argc/argv) : on utilise donc $@
    # pour transmettre les arguments fournis a localexec
    localexec=$RUN/localexec
    echo '#!/bin/sh' > $localexec 
    echo cd $RUN >> $localexec 
    echo "$VALGRIND $RUN/$EXE \$@ $ARG_CS_PAR $COMMANDE_SYRTHES "\
                 " $ARG_CS_VERIF $ARG_CS_OUTPUT $ECHOCOMMNOY -longia $LONGIA "\
                 " -longra $LONGRA $COMMANDE_PARAM " >> $localexec 
    echo "retour=\$?" >> $localexec
    echo "exit \$retour" >> $localexec
    chmod 700 $localexec
    $MPIBOOT
    $MPIRUN $localexec || erreur " A L'EXECUTION DU NOYAU " &
    #
    if [ "$MODE_COUPLAGE" = "sockets" ] ; then
      # Il faut recuperer la machine et le port dans le listing ;
      #   on utilise un sleep pour laisser le temps au noyau de demarrer et
      #   ecrire ces informations; on evite le while qui pourrait attendre eternellement
      sleep 5
      MACHPORT=""
      MACHPORT=`grep 'Communication possible sur' listing|sed -e "s/Communication possible sur //g"|sed -e "s/, port /:/g"`
      SOCKETSYR="$SOCKETSYR $MACHPORT"
    fi
    #
    # Lancement de syrthes
    if [ $COUPLAGE_SYRTHES = oui ] ; then
      ./$EXE_SYR -nbr_sat $nproc_noy $ECHOCOMMSYR $SOCKETSYR > listsyr 2>&1 
    fi
    #
    $MPIHALT
    #
  elif [ $IFOENV = 1 ] ; then
    #
    if [ ! -f $ERROR ] ; then 
      localexec=$RUN/localexec
      echo '#!/bin/sh' > $localexec 
      echo cd $RUN >> $localexec 
      echo "$VALGRIND $RUN/$EXE \$@ $ARG_CS_PAR -ifoenv $IFOENV "\
           " $ARG_CS_VERIF $ARG_CS_OUTPUT $ECHOCOMMNOY -longia $LONGIA "\
           " -longra $LONGRA $COMMANDE_PARAM "  >> $localexec 
      echo "retour=\$?" >> $localexec
      echo "exit \$retour" >> $localexec
      chmod 700 $localexec
      $MPIBOOT
      $MPIRUN $localexec || erreur " A L'EXECUTION DU NOYAU "
      $MPIHALT
    fi
    #
  else # cas IFOENV = 0
    #
    $VALGRIND $RUN/$EXE -ifoenv $IFOENV \
          -longia $LONGIA -longra $LONGRA $ARG_CS_VERIF $ARG_CS_OUTPUT $COMMANDE_PARAM \
          || erreur " A L'EXECUTION DU NOYAU "
    #
  fi
#
fi
#
########################################################################
#
# Recuperation des resultats :
#   on commence par tous les fichiers suite
#   (en cas de pb disque, on a plus de chances de pouvoir 
#    poursuivre le calcul). 
#
if [ $MODE_EXEC != pre_traitement ] ; then
 
  SUITE_AVAL=$RESU/SUITE.$SUFFIXE
  iok=1
  mkdir ${SUITE_AVAL} || iok=0
  if [ $iok = 1 ] ; then 
    for fich in suiava suiavx t1dava vorava rayava lagava* lasava* ; do 
      if [ -f $fich ] ; then 
        cp $fich ${SUITE_AVAL}
      fi
    done
  else
    for fich in suiava suiavx t1dava vorava rayava lagava* lasava* ; do 
      if [ -f $fich ] ; then 
        cp $fich $RESU/$fich.$SUFFIXE
      fi
    done
  fi

  resuser=0
  for fich in ${FICHIERS_RESULTATS_UTILISATEUR} ; do 
    if [ -f $fich ] ; then 
      resuser=1
    fi
  done
  if [ ${resuser} = 1 ] ; then 
    RES_USER=$RESU/RES_USER.$SUFFIXE
    iok=1
    mkdir ${RES_USER} || iok=0
    if [ $iok = 1 ] ; then 
      for fich in ${FICHIERS_RESULTATS_UTILISATEUR} ; do 
        if [ -f $fich ] ; then 
          cp $fich ${RES_USER}
        fi
      done
    else
      for fich in ${FICHIERS_RESULTATS_UTILISATEUR} ; do 
        if [ -f $fich ] ; then 
          cp $fich $RESU/$fich.$SUFFIXE
        fi
      done
    fi
  fi

  for fich in $PARAM $DONNEES_THERMOCHIMIE rubmail dessin ; do 
    if [ -f $fich ] ; then 
      cp $fich $RESU/$fich.$SUFFIXE
    fi
  done

  for fich in *.hst ; do
    if [ -f $fich ] ; then
      if [ ! -d $RESU/HIST.$SUFFIXE ] ; then 
        mkdir $RESU/HIST.$SUFFIXE
      fi
      cp $fich $RESU/HIST.$SUFFIXE
    fi
  done
  for fich in ush* ; do
    if [ -f $fich ] ; then
      if [ ! -d $RESU/HIST.$SUFFIXE ] ; then 
        mkdir $RESU/HIST.$SUFFIXE
      fi
      cp $fich $RESU/HIST.$SUFFIXE
    fi
  done

fi  # resultats de calcul

for fich in list* erreur* *.med *.cgns ; do 
  if [ -f $fich ] ; then 
    cp $fich $RESU/$fich.$SUFFIXE
  fi
done

# Recup du cas ensight 
#   les fichiers bord* sont des sorties rayonnement eventuelles 
#   faites dans le noyau en reponse a un besoin urgent 
#   elles seront revues. 

#   On range les repertoires $dir (=*.ensight) dans $DIR.$SUFFIXE

cas=`echo $CAS |tr "[:upper:]" "[:lower:]"`

for dir in *.ensight ; do
  if [ -d $dir ] ; then
    DIR=`echo $dir |tr "[:lower:]" "[:upper:]"`
    mkdir $RESU/$DIR.$SUFFIXE 
    if [ $? -ne 0 ] ; then
      echo Echec a la creation de $RESU/$DIR.$SUFFIXE
    else
      for fich in $dir/*  ; do 
        if [ -f $fich ] ; then    
          cp -R ${fich} $RESU/$DIR.$SUFFIXE/.
        fi
      done
    fi
  fi
done 

if [ $MODE_EXEC != pre_traitement ] ; then
 
  if [ "${RAYONNEMENT}" = "oui" ] ; then 
    for fich in bord* ; do
      if [ -f $fich ] ; then  
        if [ ! -d $RESU/CHR.$SUFFIXE ] ; then 
          mkdir $RESU/CHR.$SUFFIXE 
        fi
        cp $fich $RESU/CHR.$SUFFIXE/.
      fi
    done
  fi


  if [ "${LAGRANGIEN}" = "oui" ] ; then 
    mkdir $RESU/LAGR.$SUFFIXE
    for fich in debug* deplacement* trajectoire* frontiere* ; do 
      if [ -f $fich ] ; then 
        cp $fich $RESU/LAGR.$SUFFIXE
      fi
    done
  fi

  # Fichier de resultats Matisse
  if [ -f ${RUN}/resuMatisse ] ; then
    matisse=`grep -i matisse $DATA/$PARAM`
    if [ ! -z "$matisse" ] ; then
  # Ajout de la date sur la premiere ligne du fichier resuMatisse
      AFDATE="Date du cas                                             : "$DATE
      sed  "1i\ ${AFDATE}" ${RUN}/resuMatisse >> ${RUN}/resuMatisse.mod
      mv ${RUN}/resuMatisse.mod ${RUN}/resuMatisse  
    fi
    cp ${RUN}/resuMatisse ${RESU}/resuMatisse.$SUFFIXE
  fi

  for dir in fort_saturne ; do
    if [ -d $dir ] ; then
      mkdir $RESU/FORT.$SUFFIXE
      if [ $? -ne 0 ] ; then
        echo Echec a la creation de $RESU/FORT.$SUFFIXE
      else
        for fich in $dir/*.[f,F,c,h] ; do
          if [ -f ${fich} ] ; then 
            cp -R ${fich} $RESU/FORT.$SUFFIXE/. 
            fichbase=`basename ${fich}`
            chmod a-w $RESU/FORT.$SUFFIXE/${fichbase}
          fi
        done
      fi
    fi
  done 

  if [ $COUPLAGE_SYRTHES = oui ] ; then 
    mkdir $RESU/RESU_SYR.$SUFFIXE 
    if [ $? -ne 0 ] ; then
      echo Echec a la creation de $RESU/RESU_SYR.$SUFFIXE
    else
      for var in   $SYRTHES_ENV.save $SYRTHES_DATA $SYRTHES_DATA_RAY \
                   $SYRTHES_CORR $SYRTHES_CORR_RAY $SYRTHES_FFOR_RAY \
                   $SYRTHES_AVAL_RES1 $SYRTHES_AVAL_RES2 $SYRTHES_AVAL_CHR2 \
                   $SYRTHES_AVAL_HIST \
                   $SYRTHES_AVAL_MAIL_PEAU_FLUIDE $SYRTHES_AVAL_RESU_PEAU_FLUIDE \
                   $SYRTHES_AVAL_CHR_PEAU_FLUIDE \
                   $SYRTHES_AVAL_MAIL_RAY $SYRTHES_AVAL_RESU_RAY \
                   $SYRTHES_AVAL_CHR_RAY \
                   $SYRTHES_AVAL_HIST_RAY   ; do
          fich=$RUN/`echo $var | sed -e "s/.*\///"`
          if [ -f $fich ] ; then 	
            cp $fich $RESU/RESU_SYR.$SUFFIXE/.
          fi
      done
    fi
    #
    for dir in fort_syrthes ; do
      if [ -d $dir ] ; then
        mkdir $RESU/FORT_SYR.$SUFFIXE
        if [ $? -ne 0 ] ; then
          echo Echec a la creation de $RESU/FORT_SYR.$SUFFIXE
        else
          for fich in $dir/*.[f,F,c,h] ; do
            if [ -f ${fich} ] ; then 
              cp -R ${fich} $RESU/FORT_SYR.$SUFFIXE/.
              fichbase=`basename ${fich}`
              chmod a-w $RESU/FORT_SYR.$SUFFIXE/${fichbase}
            fi
          done
        fi
      fi
    done 
  fi

fi  # donnees d'entree et resultats de calcul
#
########################################################################
#
# Resume : fin
#
DATEFIN=`date '+%m%d%H%M'`
echo '    DATE DE FIN     : ' $DATEFIN                         >>$resume
echo '========================================================'>>$resume
#
cp $resume  $RESU/$resume.$SUFFIXE
#
########################################################################
#
#
# Fin
#
if [ -f $ERROR ] ; then 
#
  echo
  echo  "  ********************************************"
  cat                        $ERROR
  echo  "  ********************************************"
  exit 1
#
else
#
  echo
  echo  "  ********************************************"
  echo  "             Fin normale du calcul            "
  echo  "  ********************************************"
  exit 0
#
fi
#
########################################################################
#
########################################################################