Index: BOL/Replay/replay_clean.sh
===================================================================
--- BOL/Replay/replay_clean.sh	(revision 4580)
+++ BOL/Replay/replay_clean.sh	(revision 4591)
@@ -4,8 +4,22 @@
 replay_comment="replay automatic include"
 if [ $# = 0 ] ; then
-   \rm -f dump_replay*.h dump_param.h dump_ini.h call_param_repla* get_ini_modul* input tmp tmp2 tmp3 tmp2_cpp
+   \rm -f dump_replay*.h dump_param.h dump_ini.h  input tmp tmp2 tmp3 tmp2_cpp
    for file in `grep "$replay_comment" *F90 | cut -d: -f1` ; do
       sed -i"" -e "/$replay_comment/d" $file
    done
+   cat > call_param_replay.F90 <<...eod
+   subroutine call_param_replay(ngrid,nlay)
+   integer,intent(in) :: ngrid,nlay
+   stop 'In call_param_replay : You should run replay_equip.sh before runing replay[13]d'
+   return
+   end
+...eod
+   cat > call_ini_replay.F90 <<...eod
+   subroutine call_ini_replay
+   stop 'In call_ini_replay : You should run replay_equip.sh before runing replay[13]d'
+   return
+   end
+...eod
+
 else
    for file in $* ; do
Index: BOL/Replay/replay_equip.sh
===================================================================
--- BOL/Replay/replay_equip.sh	(revision 4580)
+++ BOL/Replay/replay_equip.sh	(revision 4591)
@@ -54,5 +54,5 @@
 #  * call_param_replay : sous programme d'appelle en boucle à la param
 #  * dump_ini_module.F90   : écriture de l'interface "in" de param_ini
-#  * get_ini_module    : lecture de l'interface "in" de param_ini
+#  * call_ini_replay.F90    : lecture de l'interface "in" de param_ini
 #                dans ${param_ini}_mod.bin.
 #  Par ailleurs, un programme replay1d a été ajouté dans phylmd/dyn1d
@@ -114,6 +114,6 @@
       thermcell_closure|thermcell_height|thermcell_dq|thermcell_flux2|thermcell_down| \
       thermcell_updown_dq) \
-      paramini=thermcell_ini ; inimod=thermcell_ini_mod ; klon=ngrid ; klev=nlay ;;
-   wake|wake_popdyn_2) paramini=wake_ini ; inimod=wake_ini_mod ; klon=klon ; klev=klev ;;
+      paramini=thermcell_ini ; inimod=lmdz_thermcell_ini ; klon=ngrid ; klev=nlay ;;
+   wake|wake_popdyn_1|wake_popdyn_2) paramini=wake_ini ; inimod=lmdz_wake_ini ; klon=klon ; klev=klev ;;
    *) echo Cas non prevu ; exit
 esac
@@ -142,20 +142,20 @@
 #-----------------------------------------------------------------------------
 function dump_param_open(){
-#-----------------------------------------------------------------------------
-# Opening an direct access file with one record per time-step 
-# Each record has the size and contains the arguments in and inout of the
-# routine
-#-----------------------------------------------------------------------------
-inout=$1 ; shift
-case $inout in
-   out) fort=81 ;;
-   in) fort=82
-esac
-echo '! <<< dump_param_open'
-for var in $* ; do echo 'rec_length_replay=rec_length_replay+kind('$var')*size(['$var'])' ; done
-cat <<eod
-open(${fort},file='dump_param_${inout}.bin',form='unformatted',access='direct',recl=rec_length_replay)  ! $replay_comment
-eod
-echo '! dump_param_open >>> '
+    #-----------------------------------------------------------------------------
+    # Opening an direct access file with one record per time-step 
+    # Each record has the size and contains the arguments in and inout of the
+    # routine
+    #-----------------------------------------------------------------------------
+    inout=$1 ; shift
+    case $inout in
+       out) fort=81 ;;
+       in) fort=82
+    esac
+    echo '! <<< dump_param_open'
+    for var in $* ; do echo 'rec_length_replay=rec_length_replay+kind('$var')*size(['$var'])' ; done
+    cat <<....eod
+    open(${fort},file='dump_param_${inout}.bin',form='unformatted',access='direct',recl=rec_length_replay)  ! $replay_comment
+....eod
+    echo '! dump_param_open >>> '
 }
 
@@ -176,4 +176,19 @@
 }
 
+
+#-----------------------------------------------------------------------------
+function echo_use_module(){
+#-----------------------------------------------------------------------------
+# Regle tacite : l'instruction MODULE commence à la premiere colonne.
+#                Existe-t-i une facon de la faire tomber ?
+#                En enlevant tous les blanc dans le input sans doute ...
+   param_=$1 ; shift
+   paramfile_=$1
+   if [ ! -f $paramfile_ ] ; then echo plantage which_module ; exit 1 ; fi
+   module=`grep '^[mM][oO][dD][uU][lL][eE] .*[a-Z]' $paramfile_ | head -1 | awk ' { print $2 } '`
+   if [ "$module" != "" ] ; then
+       echo USE $module, ONLY : $param_
+   fi
+}
 
 #-----------------------------------------------------------------------------
@@ -195,4 +210,8 @@
    last_line_declaration2="`sed -n -e 's/\!.*$//' -e 's/^/ /' -e '/[\ ,]real[\ ,]/p' -e '/[\ ,]integer[\ ,]/p' -e '/[\ ,]logical[\ ,]/p' -e '/[\ ,]character[\ ,]/p' tmp2_cpp | tail -1 | sed -e 's/  / /g' -e 's/ /.*/g'`"
    line_last_declaration=`cat tmp2 | tr '[A-Z]' '[a-z]' | sed -n -e "/$last_line_declaration2/="`
+   echo OK0
+   if [ "`grep -i 'end.*module' $paramfile_`" = "" ] ; then echo aka ;  line_end_module=`wc -l $paramfile_ | awk ' { print $1 } '` ; else echo akb ; line_end_module=`sed -n -e '/[eE][nN][dD] .*[mM][oO][dD][uU][lL][eE]/=' $paramfile_` ; fi
+   echo OK1
+   echo $line_end_module
    if [ "$line_last_declaration" = "" ] ; then echo line_last_declaration $line_last_declaration line $last_line_declaration2  ; exit ; fi
    if (( $# > 0 )) ; then
@@ -201,13 +220,15 @@
          -after_declarations)      targeted_line=$line_last_declaration ;;
          -before_return)           targeted_line=$line_return ;;
+         -before_end_module)       targeted_line=$line_end_module ;;
          -before_line|-after_line) linestr=`echo $1 | sed -e "s/$wtype //"` ; targeted_line=`sed -n -e "/$linestr/=" tmp2` ;;
-         *)                  echo Cas non prevu 0 where=$where in inclide_file
+         *)                  echo Cas non prevu 0 where=$where in include_file
       esac
       case $wtype in
          -after_declarations|-after_line)  line0=$(( $line_subroutine - 1 )) ;;
          -before_return|-before_line)      line0=$(( $line_subroutine - 2 )) ;;
-         *)                  echo Cas non prevu 1 where=$where in inclide_file
+         -before_end_module)               line0=-1 ;;
+         *)                  echo Cas non prevu 1 where=$where in include_file
       esac
-      echo Including line $line0 in $paramfile_ the line : $line_to_be_included
+      echo Including line $line0 + $targeted_line in $paramfile_ the line : $line_to_be_included
       linebefore_include=$(( $line0 + $targeted_line ))
      sed -i'' -e $linebefore_include"s/$/\n $line_to_be_included \!  $replay_comment/" $paramfile_ 
@@ -310,23 +331,24 @@
 if [ $nconly = false ] ; then
 
-cat > call_param_replay <<eod
+cat > call_param_replay.F90 <<eod
 subroutine call_param_replay($klon,$klev)
 USE IOIPSL, ONLY : getin
+`echo_use_module $param  $paramfile`
 IMPLICIT NONE
 integer :: ifin,irec,it,rec_length_replay=0,replay_irec0=1,replay_nt=1000
 eod
-grep 'intent.*::' input | sed -e 's/ //g' -e 's/,intent(.*[nt])//'>> call_param_replay
+grep 'intent.*::' input | sed -e 's/ //g' -e 's/,intent(.*[nt])//'>> call_param_replay.F90
 # duplicating declaration for inout variables
 
 for var in $varinout0 ; do
-    sed -e 's/::/ :: /' -e 's/,/ , /g' -e 's/$/ /' input | grep 'intent.*inout.*::.* '$var' ' | sed -e 's/ //g' -e 's/,intent(.*[nt])//' | sed -e 's/::.*$/, allocatable, save :: '$var'_Replay0/' | sed -e 's/'$klon'/:/' -e 's/'$klev'/:/' >> call_param_replay
+    sed -e 's/::/ :: /' -e 's/,/ , /g' -e 's/$/ /' input | grep 'intent.*inout.*::.* '$var' ' | sed -e 's/ //g' -e 's/,intent(.*[nt])//' | sed -e 's/::.*$/, allocatable, save :: '$var'_Replay0/' | sed -e 's/'$klon'/:/' -e 's/'$klev'/:/' >> call_param_replay.F90
 done
 # Initalisation, shared with dump_param1.sh
-dump_param_open "in" $varin0 >> call_param_replay
+dump_param_open "in" $varin0 >> call_param_replay.F90
 for var in $varinout0 ; do
-    sed -e 's/::/ :: /' -e 's/,/ , /g' -e 's/$/ /' input | grep 'intent.*inout.*::.* '$var' ' | sed -e 's/intent(.*t)//' -e 's/^.*(/allocate('$var'_Replay0(/' -e 's/).*$/))/' >> call_param_replay
+    sed -e 's/::/ :: /' -e 's/,/ , /g' -e 's/$/ /' input | grep 'intent.*inout.*::.* '$var' ' | sed -e 's/intent(.*t)//' -e 's/^.*(/allocate('$var'_Replay0(/' -e 's/).*$/))/' >> call_param_replay.F90
 done
 
-cat >> call_param_replay <<eod
+cat >> call_param_replay.F90 <<eod
 call getin('replay_nt',replay_nt)
 call getin('replay_irec0',replay_irec0)
@@ -342,9 +364,9 @@
 eod
 
-block_Replay0 "it == 1"          _Replay0   ""       $varinout0 >> call_param_replay
-block_Replay0 "replay_irec0 < 0" ""         _Replay0 $varinout0 >> call_param_replay
-get_subroutine_arg $param $paramfile | sed -e 's/subroutine/   call/' >> call_param_replay
-block_Replay0 "replay_irec0 < 0" _Replay0   ""       $varinout0 >> call_param_replay
-cat >> call_param_replay <<eod
+block_Replay0 "it == 1"          _Replay0   ""       $varinout0 >> call_param_replay.F90
+block_Replay0 "replay_irec0 < 0" ""         _Replay0 $varinout0 >> call_param_replay.F90
+get_subroutine_arg $param $paramfile | sed -e 's/subroutine/   call/' >> call_param_replay.F90
+block_Replay0 "replay_irec0 < 0" _Replay0   ""       $varinout0 >> call_param_replay.F90
+cat >> call_param_replay.F90 <<eod
 enddo
 return
@@ -410,14 +432,14 @@
 
 #-----------------------------------------------------------------------------
-# get_ini_module gere l'initialisation du module en mode replay
+# call_ini_replay.F90 gere l'initialisation du module en mode replay
 #-----------------------------------------------------------------------------
 if [ $nconly = false -a $paramini != None ] ; then
-    cat > get_ini_module <<....eod............................................
-    subroutine get_ini_module
+    cat > call_ini_replay.F90 <<....eod............................................
+    subroutine call_ini_replay
     use $inimod
     IMPLICIT NONE
 ....eod............................................
-    grep -i intent.in $inimod.F90  |  tr '[A-Z]' '[a-z]' | sed -e 's/,.*intent.i.*)//' >> get_ini_module
-    cat >> get_ini_module <<....eod...........................................
+    grep -i intent.in $inimod.F90  |  tr '[A-Z]' '[a-z]' | sed -e 's/,.*intent.i.*)//' >> call_ini_replay.F90
+    cat >> call_ini_replay.F90 <<....eod...........................................
     open(90,file='$inimod.bin',form='unformatted')
     read(90) $varinmodv
@@ -425,20 +447,8 @@
 ....eod...........................................
     #get_subroutine_arg $paramini $inimod.F90 ; exit
-    get_subroutine_arg $paramini $inimod.F90 | sed -e 's/subroutine/call/' >> get_ini_module
-    cat >> get_ini_module <<....eod...........................................
+    get_subroutine_arg $paramini $inimod.F90 | sed -e 's/subroutine/call/' >> call_ini_replay.F90
+    cat >> call_ini_replay.F90 <<....eod...........................................
     return
     end
 ....eod...........................................
 fi # nconly = false
-
-#-----------------------------------------------------------------------------
-# Inclusion de l'ecriture de l'interface de l'initialisation
-#-----------------------------------------------------------------------------
-
-if [ $nconly = false ] ; then
-     for file in get_ini_module call_param_replay ; do sed -i'' -e "s/$/					\!$replay_comment/"  $file ; done
-     cat get_ini_module >> $inimod.F90
-     cat call_param_replay >> $paramfile
-fi
-
-#\rm -f tmp input
Index: BOL/Replay/replay_param.sh
===================================================================
--- BOL/Replay/replay_param.sh	(revision 4580)
+++ 	(revision )
@@ -1,250 +1,0 @@
-#!/bin/bash
-
-#=============================================================================
-#  F. Hourdin : 2022/05/03
-#
-#  Objet :
-#  -----
-#  Script préparant les programes pour rejouer (replay) une paramétrisation
-#  ou un morceau de paramétriation.
-#
-#
-#  Applicabilité :
-#  ---------------
-#  Est fait pour rejouer des paramétisation de LMDZ organisées comme
-#    des calcul sur des successions de colonnes indépendantes (boucle
-#    interne en $klon) de $klev niveaux verticaux.
-#  Demande que la paramétrisation répondent aux règles de codage suivantes :
-#  1) Les routines de calcul et les routines ou fonction qu'elles appellent
-#     n'ont que deux interfaces : A) les arguments d'entrée
-#                                 B) le use d'un unique module
-#     Entre autre, les dimensions de la paramétrisation sont passés
-#     en argument, ce qui permet une allocation dynamique implicite
-#     de toutes les variables.
-#  2) le module d'initialisation doit lui même être initialisé par 
-#     une unique routine pilotée entièrement par ses arguments.
-#  3) Toutes les variables d'interface doivent être déclarées intent in
-#     ou intent out.
-#  On appelera la paramétriation "param" et l'intialisation "param_ini"
-#     mais les noms de fichiers sont en argument dans le script.
-#
-#
-#  Principe :
-#  ----------
-#  Dans une première simulation, on écrit dans un fichier binaire toutes
-#  les variables "intent in" de la routine d'initialisation et de la routine
-#  de calcul.
-#
-#
-#  En pratique :
-#  -------------
-#
-#  Le script est commandé par les variables suivantes
-#   param=wake             # nom de la subroutine (à l'interireur du fichier)
-#   paramini=wake_ini  # nom de la subroutine d'intialisation
-#   inimod= # nom du module contenant $param_ini
-#   klon=klon ; klev=klev  # nom des dimensions horiz; vert utilisée
-#
-#  Le fichier ${paramfile} contenant $param est detecté automatiquement
-#  Le script crée 4 fichiers
-#  * dump_param.h          : écriture de l'interface "in" de param (dump_param.bin fort.82)
-#  * call_param_replay.F90 : sous programme d'appelle en boucle à la param
-#  * dump_ini_module.F90   : écriture de l'interface "in" de param_ini
-#  * get_ini_module.F90    : lecture de l'interface "in" de param_ini
-#                dans ${param_ini}_mod.bin.
-#  Par ailleurs, un programme replay1d a été ajouté dans phylmd/dyn1d
-#        qui appelle call_param_replay
-#  Le script ajoute par ailleurs quelques lignes dans ${paramfile} et
-#        ${param_ini}.F90
-#  replay_clean.sh élimine toutes les lignes ajoutées 
-#
-#
-#  A travailler :
-#  --------------
-#  * détecter automatiquement le fichier contenant l'intialisation
-#  * détecter automatiquement les dimensions
-#  * avoir un moyen de vérifier si les variables intent in et out sont
-#    bien les bonnes.
-#  * test en 3D.
-#  * Initialisation plus simple de la routine getin_p
-#  * Des choix sur la facon de controler l'initialisation et le pb des getin
-#  * Modifier la compilation du 1D pour pouvoir compiler lmdz1d et replay1d
-#  * Comprendre pourquoi le replay de wake ne semble pas donner une convegence
-#      numerique avec la version initiale
-#  * L'identification des variables intent in & out pour l'ecriture dans .h
-#     va sans doute foirer si plusieurs routines dans le même fichier.
-#     On pourrait d'ailleurs sortir toutes les variables locales également.
-#     En option par exemple
-#  * Corriger create_make_gcm (pour le main) et makelmdz (pour les checks
-#     sur la necessitee d'appeler create_make_gcm)
-#  * Mettre en option le fait de pouvoir sortir non seulement toutes
-#     les variables d'interface mais même toutes les variables internes.
-#
-#=============================================================================
-
-param=$1
-case $param in
-   thermcell_main|thermcell_plume_6A|thermcell_env|thermcell_height|thermcell_dry|\
-      thermcell_closure|thermcell_height|thermcell_dq|thermcell_flux2|thermcell_down) \
-      paramini=thermcell_ini ; inimod=thermcell_ini_mod ; klon=ngrid ; klev=nlay ;;
-   wake) paramini=wake_ini ; inimod=wake_ini_mod ; klon=klon ; klev=klev ;;
-   *) echo Cas non prevu ; exit
-esac
-
-replay_comment="replay automatic include"
-
-#-----------------------------------------------------------------------------
-# Transformer l'entete d'une subroutine en un call
-#-----------------------------------------------------------------------------
-
-function get_subroutine_arg(){
-   cat $1 | tr '[A-Z]' '[a-z]' > tmp
-   line1=`sed -n -e '/subrou.*(/=' tmp | head -1 `
-   line2=`tail -n +$line1 tmp | sed -n -e '/)/=' | head -1`
-   tail -n +$line1 tmp | sed -n -e 1,${line2}p
-}
-
-#-----------------------------------------------------------------------------
-function extract_subroutine(){
-#-----------------------------------------------------------------------------
-   # $1 nom de la subroutine
-   # $2 nom du fichier
-   # cat $2 | tr '[A-Z]' '[a-z]' > tmp
-   cpp $2 | tr '[A-Z]' '[a-z]' > tmp
-   name_min=`echo $1 | tr '[A-Z]' '[a-z]'`
-   line1=`sed -n -e "/subrou.*${name_min}.*(/=" tmp | head -1 `
-   tail -n +$line1 tmp > tmp2
-   line2=`sed -n -e "/[Rr][Ee][Tt][Uu][Rr][Nn]/=" tmp2 | head -1`
-   head -$line2 tmp2
-   \rm -f tmp tmp2
-}
-
-#-----------------------------------------------------------------------------
-function get_param_file(){
-#-----------------------------------------------------------------------------
-  grep -i "subro.* $1[\ (]" *.F90 | sed -e 's/ //g' | grep "$1(" | cut -d: -f1
-}
-
-#-----------------------------------------------------------------------------
-# Identification et passage à la casse du bas pour du fichier contenant la param
-#-----------------------------------------------------------------------------
-
-paramfile=`get_param_file $param`
-echo La parametrisation $param est contenue dans le fichier $paramfile
-if [ `echo ${paramfile} | wc -w` != 1 ] ; then exit ; fi
-extract_subroutine $param $paramfile > input
-
-#-----------------------------------------------------------------------------
-# Liste des variables d'intent in pour stokage
-#-----------------------------------------------------------------------------
-
-varin0=`grep inten.*.in input | sed -e '/\!.*$/d' | cut -d: -f3 | sed -e 's/,/ /g'`
-echo varin0 $varin0
-varin=`echo $varin0 | sed -e 's/ /,/g' -e "s/,,,/,/g" -e "s/,,/,/g"`
-echo varin $varin
-output=full # Attention, l'option full ne marche pas a cause de tableaux locaux undef
-nvar0D=0 ; nvar1D=0 ; nvar2D=0
-case $output in
-   light) search_str='real.*intent' ;;
-   full) search_str='real'
-esac
-var_1D=`grep -i "$search_str" input | grep $klon | sed -e 's/!.*$//' -e /$klev/d | cut -d: -f3 | sed -e 's/,/ /g'`
-var_2D=`grep -i "$search_str" input | grep $klon | grep $klev | cut -d: -f3 | sed -e 's/!.*$//' -e 's/,/ /g'`
-echo varin  : $varin
-echo var_1D : $var_1D
-echo var_2D : $var_2D
-
-#-----------------------------------------------------------------------------
-# Ecriture de la routine d'appel a la parametrisation en mode replay
-#-----------------------------------------------------------------------------
-
-cat > call_param_replay.F90 <<eod
-subroutine call_param_replay($klon,$klev)
-IMPLICIT NONE
-integer ifin
-eod
-head -200 input | grep intent | sed -e 's/ //g' -e 's/,intent(.*[nt])//'>> call_param_replay.F90
-cat >> call_param_replay.F90 <<eod
-read(82,iostat=ifin) $varin
-if (ifin<0) stop "Fin du fichier fort.82"
-eod
-get_subroutine_arg $paramfile | sed -e 's/subroutine/call/' >> call_param_replay.F90
-echo return >> call_param_replay.F90
-echo end >> call_param_replay.F90
-
-#-----------------------------------------------------------------------------
-# Creation d'un .h d'ecriture de toutes les variables intent in & out
-#-----------------------------------------------------------------------------
-
-paraminc=dump_param.h
-cat > $paraminc <<eod
-   write(81) $varin
-eod
-for var in $var_1D ; do
-echo "call iotd_ecrit_seq('"$var"',1,'"$var"',' ',"$var")" >> $paraminc
-done
-for var in $var_2D ; do
-echo "call iotd_ecrit_seq('"$var"',"$klev",'"$var"',' ',"$var")" >> $paraminc
-done
-  
-#-----------------------------------------------------------------------------
-# dump_ini_module gere l'ecriture des variables d'interface de l'intialisation
-# du module en mode replay
-#-----------------------------------------------------------------------------
-
-varinmod=`grep -i 'intent.in' $inimod.F90 | sed -e 's/\!.*$//' | cut -d: -f3 | sed -e 's/,/ /g'`
-varinmodv=`echo $varinmod | sed -e 's/ /,/g'`
-cat > dump_ini.h <<eod
-open(90,file='$inimod.bin',form='unformatted')
-write(90) $varinmodv
-close(90)
-eod
-
-
-#-----------------------------------------------------------------------------
-# get_ini_module gere l'initialisation du module en mode replay
-#-----------------------------------------------------------------------------
-
-cat > get_ini_module.F90 <<eod
-subroutine get_ini_module
-use $inimod
-IMPLICIT NONE
-eod
-grep -i intent.in $inimod.F90  |  tr '[A-Z]' '[a-z]' | sed -e 's/,.*intent.i.*)//' >> get_ini_module.F90
-cat >> get_ini_module.F90 <<eod
-open(90,file='$inimod.bin',form='unformatted')
-read(90) $varinmodv
-close(90)
-eod
-get_subroutine_arg $inimod.F90 | sed -e 's/subroutine/call/' >> get_ini_module.F90
-cat >> get_ini_module.F90 <<eod
-return
-end
-eod
-
-#-----------------------------------------------------------------------------
-# On nettoye les inclusions précédente dans les fichiers .F90
-#-----------------------------------------------------------------------------
-
-for file in `grep "$replay_comment" *.F90 2> /dev/null | cut -d: -f1` ; do
-   sed -i"" -e "/$replay_comment/d" $file
-done
-line=`sed -n -e "/CALL wake_ini/=" physiq_mod.F90 | head -1`
-cp physiq_mod.F90 physiq_mod.$$
-sed -i"" -e "${line}s/$/\n   CALL iophys_ini(pdtphys) ! $replay_comment\n   open(81,file='dump_param.bin',form='unformatted')  ! $replay_comment/" physiq_mod.F90
-
-
-#-----------------------------------------------------------------------------
-# Inclusion d'un include dans la parametrisation
-#-----------------------------------------------------------------------------
-
-line=`sed -n -e "/^.*[Rr][Ee][Tt][Uu][Rr][Nn].*$/=" $paramfile | head -1`
-sed -i"" -e "${line}s/^.*$/   include \"$paraminc\" ! $replay_comment \n RETURN/" $paramfile
-
-#-----------------------------------------------------------------------------
-# Inclusion de l'ecriture de l'interface de l'initialisation
-#-----------------------------------------------------------------------------
-
-sed -i'' -e "s/^.*[Rr][Ee][Tt][Uu][Rr][Nn].*$/include \"dump_ini.h\" ! $replay_comment \n RETURN/" $inimod.F90
-
-#\rm -f tmp input
