#!/bin/bash
set -eu  # error on command failure, and on unset variables
export LC_ALL=C  # standardize awk format

###########################################################################
# Author : Laurent Fairhead et Frédéric Hourdin
# Usage  : install_lmdz.sh -help
#
# bash installation script of the LMDZ model on different computer types :
# Linux PC, "mesocentre" (IPSL-UPMC, IPSL-X), super-computer (IDRIS)
#
# The model is downloaded in the following directory tree
# $MODEL/modipsl/modeles/...
# using the "modipsl" infrastructure created by the "IPSL"
# for coupled (atmosphere/ocean/vegetation/chemistry) climate modeling
# activities.
# Here we only download atmospheric (LMDZ) and vegetation (ORCHIDEE)
# components.
#
# The sources of the models can be found in the "modeles" directory.
# In the present case, LMDZ, ORCHIDEE, and IOIPSL or XIOS (handling of
# input-outputs using the NetCDF library).
#
# The script downloads various source files (including a version of NetCDF)
# and utilities, compiles the model, and runs a test simulation in a
# minimal configuration.
#
# Prerequisites : pgf90/gfortran, bash or ksh, wget , gunzip, tar, ...
#
# Modif 18/11/2011
#    changes for option real 8.
#      We compile with -r8 (or equivalent) and -DNC_DOUBLE for the GCM
#      but with -r4 for netcdf. Variable real must be set to
#      r4 or r8 at the beginning of the script below.
#
###########################################################################

### Functions

function myget { # Get a file from LMDZ repository
  local url=$1

  local filename
  filename=$(basename "$url")

  wget --no-check-certificate -nv "http://lmdz.lmd.jussieu.fr/pub/$url"
  if [[ $filename =~ .*\.(ba)?sh ]]; then chmod +x "$filename"; fi
}

function set_default_params {
    # Valeur par défaut des parametres

    # 04_2021 : tester si r4 marche encore !
    real="r8"  # ou "r4"

    svn=""
    version="20231022.trunk"

    getlmdzor=1
    netcdf=1   #  1: for automatic installation;
    #          or 0: do not install NetCDF and look for it in standard locations;
    #          or absolute path: look for NetCDF there
    check_software_linux=1
    ioipsl=1
    bench=1
    pclinux=1
    pcmac=0 # default: not on a Mac
    compiler="gfortran"
    if [[ $(gfortran -dumpversion | cut -d. -f1) -ge 10 ]]; then allow_arg_mismatch="-fallow-argument-mismatch"; fi
    SCM=0
    # surface/vegetation scheme treatment
    # controlled by the single variable veget which can have the following values
    # - NONE: bucket scheme (default)
    # - CMIP6: orchidee version used in CMIP exercise, rev 5661
    # - number: orchidee version number
    veget="NONE"
    # choose the resolution for the bench runs
    # grid_resolution= 32x24x11 or 48x36x19 for tests (test without ORCHIDEE)
    #                  96x71x19  standard configuration
    grid_resolution="32x32x39"  # "48x36x19", "96x95x39", "144x142x79"
    # choose the physiq version you want to test
    #physiq=NPv6.0.14splith
    physiq=""

    ## parallel can take the values none/mpi/omp/mpi_omp
    parallel="none"  # "mpi_omp"
    idris_acct="lmd"
    trusting="testing"
    OPT_GPROF=""
    OPT_MAKELMDZ=""
    MODEL=""

    ## also compile XIOS? (and more recent NetCDF/HDF5 libraries) Default=no
    with_xios="n"
    opt_makelmdz_xios=""

    ## compile with oldrad/rrtm/ecrad radiatif code (Default=rrtm)
    rad="rrtm"

    ## compile_with_fcm=1 : use makelmdz_fcm (1) or makelmdz (0)
    compile_with_fcm=1

    #Compilation with Cosp (cosp=NONE/v1/v2; default=NONE)
    cosp="NONE"
    opt_cosp=""

    # Check if on a Mac
    if [[ $(uname) = "Darwin" ]]; then
        pcmac=1
        export MAKE="make"
    fi

    env_file=""
    optim=""
    arch="local"

    local mpi_file
    mpi_file=$(readlink -f "$(which mpif90)")
    path_mpi=$(dirname "$mpi_file")
    root_mpi=$(dirname "$path_mpi")
}

function read_cmdline_args {
    while (($# > 0)); do
        case $1 in
            "-h") cat <<........fin
        $0 [ -v version ] [ -r svn_release ]
               [ -parallel PARA ] [ -d GRID_RESOLUTION ] [ -bench 0/1 ]
               [-name LOCAL_MODEL_NAME] [-gprof] [-opt_makelmdz] [-rad RADIATIF]

        -v       "version" like 20150828.trunk
                 see http://www.lmd.jussieu.fr/~lmdz/Distrib/LISMOI.trunk

        -r       "svn_release" : either the svn release number or "last"

        -compiler gfortran|ifort|pgf90 (default: gfortran)

        -parallel PARA : can be mpi_omp (mpi with openMP) or none (for sequential)

        -d        GRID_RESOLUTION should be among the available benchs if -bench 1
                  among which : 48x36x19, 48x36x39
                  if wanting to run a bench simulation in addition to compilation
                  default : 48x36x19

        -bench     activating the bench or not (0/1). Default 1

        -testing/unstable

        -name      LOCAL_MODEL_NAME : default = LMDZversion.release

        -netcdf    0, 1 or PATH
                       0: do not download NetCDF, look for it in standard locations
                   1: download and compile NetCDF
                       PATH: full path to an existing installed NetCDF library

        -xios      also download and compile the XIOS library
                   (requires the NetCDF4-HDF5 library, also installed by default)
                   (requires to also have -parallel mpi_omp)

        -gprof     to compile with -pg to enable profiling with gprof

        -cosp      to run without our with cospv1 or cospv2 [none/v1/v2]

        -rad RADIATIF can be oldrad, rrtm or ecrad radiatif code

        -nofcm     to compile without fcm

        -SCM        install 1D version automatically

        -debug      compile everything in debug mode

        -opt_makelmdz     to call makelmdz or makelmdz_fcm with additional options

        -physiq    to choose which physics package to use

        -env_file  specify an arch.env file to overwrite the existing one

        -veget surface model to run [NONE/CMIP6/xxxx]

........fin
                  exit 1;;
            "-v") version=$2; shift; shift;;
            "-r") svn=$2; shift; shift;;
            "-compiler") compiler=$2
                         case $compiler in
                             "gfortran"|"ifort"|"pgf90") compiler=$2; shift
                                                         shift;;
                             *) echo "Only gfortran , ifort or pgf90 for the " \
                                     "compiler option"
                                exit 1
                         esac;;
            "-d") grid_resolution=$2; shift; shift;;
            "-gprof") OPT_GPROF="-pg"; shift;;
            "-unstable"|"-testing") trusting=$(echo "$1" | cut -c2-) ; shift;;
            "-cosp") cosp=$2
                     case $cosp in
                         "none"|"v1"|"v2") cosp=$2; shift; shift;;
                         *) echo "Only none v1 v2 for cosp option"; exit 1
                     esac;;
            "-nofcm") compile_with_fcm=0; echo "This option will be reactivated soon (promesse du 8dec2022)"; exit 1;  shift;;
            "-SCM") SCM=1; shift;;
            "-opt_makelmdz") OPT_MAKELMDZ="$2"; shift; shift;;
            "-rrtm") if [[ $2 = "false" ]]; then
                         rad="oldrad"
                     else
                         rad="rrtm"
                     fi
                     shift; shift;;
            "-rad") rad=$2
                    case $rad in
                        "oldrad"|"rrtm"|"ecrad") rad=$2; shift; shift;;
                        *) echo "Only oldrad rrtm ecrad for rad option"; exit 1
                    esac;;
            "-parallel") parallel=$2
                         case $parallel in
                             "none"|"mpi"|"omp"|"mpi_omp") parallel=$2; shift; shift;;
                             *) echo "Only none mpi omp mpi_omp for the parallel option"; exit 1
                         esac;;
            "-bench") bench=$2; shift; shift;;
            "-debug") optim=-debug; shift;;
            "-name") MODEL=$2; shift; shift;;
            "-netcdf") netcdf=$2; shift; shift;;
            "-physiq") physiq=$2; shift; shift;;
            "-xios") with_xios="y"; shift;;
            "-env_file") env_file=$2; shift; shift;;
            "-veget") veget=$2; shift; shift;;
            *)  bash install_lmdz.sh -h; exit 1
        esac
    done

    # Option de compilation pour Cosp
    case $cosp in
        v1) opt_cosp="-cosp true";;
        v2) opt_cosp="-cospv2 true";;
        *) opt_cosp=""
    esac

    # Check on veget version
    if [[ $veget != 'NONE' && $veget != "CMIP6" ]]; then
        re='^[0-9]+$'
        if ! [[ $veget =~ $re ]]; then
            echo 'Valeur de l option veget non valable'; exit 1
        fi
    fi

    #Define veget-related suffix for gcm name
    if [[ $veget = 'NONE' ]]; then
        suff_orc=''
        #For use with tutorial, orchidee_rev is also defined (will be
        #written in surface_env at the end of the script)
        orchidee_rev=''
    else
        suff_orc='_orch'
    fi


    if [[ $parallel = "none" ]]; then
        sequential=1; suff_exe='_seq'
    else
        sequential=0; suff_exe='_para_mem'
    fi

    #Chemin pour placer le modele
    if [[ $MODEL = "" ]]; then MODEL="./LMDZ$version$svn$optim"; fi

    ## if also compiling XIOS, parallel must be mpi_omp
    if [[ $with_xios = "y" && $parallel != "mpi_omp" ]]; then
        echo "Error, you must set -parallel mpi_omp if you want XIOS"; exit 1
    fi

    if [[ $with_xios = "y" ]]; then
        opt_makelmdz_xios="-io xios"
    fi

    if [[ $cosp = "v2" && $with_xios = "n" ]]; then
        echo "Error, Cospv2 cannot run without Xios"; exit 1
    fi
}

function check_available_software {
    if [[ $check_software_linux = 1 ]]; then
        echo "################################################################"
        echo "Check if required software is available"
        echo "################################################################"

        for logiciel in wget tar gzip make $compiler gcc cmake m4 c++; do
            if [[ $(which "$logiciel") = "" ]]; then
                echo "You must first install $logiciel on your system"; exit 1
            fi
        done

        cat <<eod > tt.f90
    print*,'coucou'
    end
eod
        $compiler tt.f90 || a.out
        ./a.out >| tt
        if [[ $(< tt sed -e 's/ //g' ) != "coucou" ]]; then
            echo "problem installing with compiler $compiler"; exit 1; fi
        \rm tt a.out tt.f90
    fi
}

function download_model {
    mkdir -p "$MODEL"
    MODEL=$(readlink -f "$MODEL"); echo "$MODEL"  # absolute path

    if [[ $getlmdzor = 1 && ! -d $MODEL/modipsl ]]; then
        echo "##########################################################"
        echo "Download a slightly modified version of  LMDZ"
        echo "##########################################################"
        cd "$MODEL"
        getlog="$(pwd)/get.log"
        echo "logfile : $getlog"
        myget "src_archives/$trusting/modipsl.$version.tar.gz" >> get.log 2>&1
        echo "install_lmdz.sh wget_OK $(date)"
        gunzip "modipsl.$version.tar.gz" >> get.log 2>&1
        tar xf "modipsl.$version.tar" >> get.log 2>&1
        \rm "modipsl.$version.tar"
    fi

    if [[ $svn != "" ]]; then
        mysvn=$svn
    else
        mysvn="$(grep 'Revision: [0-9]' "$MODEL"/Read*.md | awk ' { print $2 } ' 2>/dev/null)"
    fi
    echo "SVN revision used: $mysvn"
}

function setup_local_arch {
    # Setup local arch, and correspondance between arch names accross different programs

    case $arch in
        local)
            arch_ioipsl="gfortran"
            arch_xios="local"

            cat <<EOF >"$MODEL/modipsl/modeles/IOIPSL/arch/arch-${arch_ioipsl}.path"  # fix bad IOIPSL arch files...
NETCDF_INCDIR="\$(nf-config --fflags)"
NETCDF_LIBDIR="\$(nf-config --flibs)"
EOF
        ;;
      *) arch_ioipsl=$arch
         arch_xios=$arch
  esac
}

function install_netcdf {
    echo "Installing Netcdf"

    if [[ $netcdf = 0 ]]; then
        ncdfdir=$(nc-config --prefix)
    else
        cd "$MODEL"

        case $compiler in
          gfortran) opt1="-compiler gnu"; opt2="-CC gcc -FC gfortran -CXX g++";;
          ifort)  opt1="-compiler intel"; opt2="-CC icc -FC ifort -CXX icpc";;
          pgf90)  opt1="-compiler pgf90"; opt2="-CC pgcc -FC pgf90 -CXX pgCC";;
          *)      echo "unexpected compiler $compiler" for netcdf; exit 1
        esac

        case $with_xios in
            n) script_install_netcdf="install_netcdf4_hdf5_seq.bash"
               ncdfdir="netcdf4_hdf5_seq"
               opt_="$opt1";;
            y) script_install_netcdf="install_netcdf4_hdf5.bash"
               ncdfdir="netcdf4_hdf5"
               opt_="$opt2 -MPI $root_mpi";;
            *) echo "with_xios=$with_xios, should be n or y"; exit 1
        esac
        if [[ $netcdf = 1 ]]; then
           ncdfdir="$MODEL/$ncdfdir"
        else
           mkdir -p "$netcdf"; ncdfdir="$netcdf/$ncdfdir"
        fi

        echo "Repertoire netcdf $ncdfdir"
        if [[ ! -d $ncdfdir ]]; then
            netcdflog=$(pwd)/netcdf.log
            echo "----------------------------------------------------------"
            echo "Compiling the Netcdf library"
            echo "----------------------------------------------------------"
            echo "log file : $netcdflog"
            myget script_install/$script_install_netcdf >> "$netcdflog" 2>&1
            chmod u=rwx $script_install_netcdf
            # shellcheck disable=SC2086
            ./$script_install_netcdf -prefix "$ncdfdir" $opt_ >> "$netcdflog" 2>&1
        fi

        #----------------------------------------------------------------------------
        # LF rajout d'une verrue, pour une raison non encore expliquee,
        # la librairie est parfois rangée dans lib64 et non dans lib
        # par certains compilateurs
        if [[ ! -e lib && -d lib64 ]]; then ln -s lib64 lib; fi
        #----------------------------------------------------------------------------

        echo "install_lmdz.sh netcdf_OK $(date)"
    fi

    cat >test_netcdf90.f90 <<EOF
    use netcdf
    print *, "NetCDF library version: ", nf90_inq_libvers()
    end
EOF

    if $compiler -I"$ncdfdir"/include test_netcdf90.f90 -L"$ncdfdir"/lib -lnetcdff \
              -lnetcdf -Wl,-rpath="$ncdfdir"/lib && ./a.out
    then
        \rm test_netcdf90.f90 a.out
    else
        cat <<EOF
Failed test program using NetCDF-Fortran. You can:
- check that you have NetCDF-Fortran installed in your system
- or specify an installation directory with option -netcdf of install_lmdz.sh
- or download and compile NetCDF-Fortran with option -netcdf 1 of nstall_lmdz.sh
EOF
        exit 1
    fi
}

function install_IOIPSL {  # via fcm
  if [[ ! -f $MODEL/modipsl/lib/libioipsl.a ]]; then
    cd "$MODEL/modipsl/modeles/IOIPSL"
    ioipsllog="$(pwd)/ioipsl.log"
    echo "Compiling IOIPSL, the interface library with Netcdf $(date) (log: $ioipsllog)"

    if ! ./makeioipsl_fcm -arch "$arch_ioipsl" -job 8 > "$ioipsllog" 2>&1; then
      echo "IOIPSL compile failed, exiting"; exit 1
    fi
    cp lib/* ../../lib
    echo "IOIPSL compiled $(date)"
  fi
}

function install_XIOS {
    if [[ $with_xios = "y"  && ! -f "$MODEL/modipsl/modeles/XIOS/lib/libxios.a" ]]; then
        cd "$MODEL/modipsl/modeles"
        xioslog="$(pwd)/xios.log"
        echo "##########################################################"
        echo "Compiling XIOS (log $xioslog) $(date)"
        echo "##########################################################"
        myget script_install/install_xios.bash

        if ! ./install_xios.bash -prefix "$MODEL/modipsl/modeles" -arch "$arch_xios" > "$xioslog" 2>&1; then
            echo "XIOS compilation failed, exiting"; exit 1
        fi

        echo "Compiled XIOS $(date)"
    fi
}

echo "install_lmdz.sh DEBUT $(date)"

set_default_params
read_cmdline_args "$@"
check_available_software
download_model
setup_local_arch
install_netcdf
install_IOIPSL
install_XIOS

exit 0




################################################################
# Specificite des machines
################################################################

hostname=$(hostname)
#case ${hostname:0:5} in
#    *)       if [[ $parallel = none || -f /usr/bin/mpif90 ]]; then
#                 path_mpi=$(which mpif90 | sed -e s:/mpif90::);
#                 if [[ -d /usr/lib64/openmpi ]]; then
#                     root_mpi="/usr/lib64/openmpi"
#                 else
#                     root_mpi="/usr"
#                 fi
#             else
#                 echo "Cannot find mpif90";
#                 if [[ $parallel = none ]]; then exit 1; fi;
#             fi;
#             if [[ $parallel != none ]]; then
#                 root_mpi=$(which mpif90 | sed -e s:/bin/mpif90::)
#                 path_mpi=$(which mpif90 | sed -e s:/mpif90::)
#                 export LD_LIBRARY_PATH=${root_mpi}/lib:$LD_LIBRARY_PATH
#             fi
#             par_comp=${path_mpi}/mpif90;
#             mpirun=${path_mpi}/mpirun;
#             arch="local" ;
#             make="make";
#             o_ins_make="-t g95"
#esac

## Flags for parallelism:
#if [[ $parallel != none ]]; then
#    # MPI_LD are the flags needed for linking with MPI
#    MPI_LD="-L${root_mpi}/lib -lmpi"
#    if [[ $compiler = "gfortran" ]]; then
#        # MPI_FLAGS are the flags needed for compilation with MPI
#        MPI_FLAGS="-fcray-pointer"
#        # OMP_FLAGS are the flags needed for compilation with OpenMP
#        OMP_FLAGS="-fopenmp -fcray-pointer"
#        # OMP_LD are the flags needed for linking with OpenMP
#        OMP_LD="-fopenmp"
#    elif [[ $compiler = "ifort" ]]; then
#        MPI_FLAGS=""
#        OMP_FLAGS="-openmp"
#        OMP_LD="-openmp"
#    else # pgf90
#        MPI_FLAGS=""
#        OMP_FLAGS="-mp"
#        OMP_LD="-mp"
#    fi
#fi
#
#
#echo "################################################################"
#echo  "Choix des options de compilation"
#echo "################################################################"
#
#export FC=$compiler
#export F90=$compiler
#export F77=$compiler
#export CPPFLAGS=
#OPTIMNC=""
#BASE_LD="$OPT_GPROF"
#OPTPREC="$OPT_GPROF"
#ARFLAGS="rs"
#if [[ $(lsb_release -i -s) = "Ubuntu" ]]; then
#    if [[ $(lsb_release -r -s | cut -d. -f1) -ge 16 ]]; then
#        ARFLAGS="rU"
#    fi
#fi
#
#if [[ $compiler = "gfortran" ]]; then
#   OPTIM="-O3 $allow_arg_mismatch"
#   OPTDEB="-g3 -Wall -fbounds-check -ffpe-trap=invalid,zero,overflow -O0 -fstack-protector-all -fbacktrace -finit-real=snan  $allow_arg_mismatch"
#   OPTDEV="-Wall -fbounds-check  $allow_arg_mismatch"
#   fmod="I "
#   OPTPREC="$OPTPREC -cpp -ffree-line-length-0"
#   if [[ $real = r8 ]]; then OPTPREC="$OPTPREC -fdefault-real-8 -DNC_DOUBLE"; fi
#   export F90FLAGS=" -ffree-form $OPTIMNC"
#   export FFLAGS=" $OPTIMNC"
#   export CC=gcc
#   export CXX=g++
#   export fpp_flags="-P -C -traditional -ffreestanding"
#
#elif [[ $compiler = mpif90 ]]; then
#    OPTIM="-O3"
#    OPTDEB="-g3 -Wall -fbounds-check -ffpe-trap=invalid,zero,overflow -O0 -fstack-protector-all"
#    OPTDEV="-Wall -fbounds-check"
#    BASE_LD="$BASE_LD -lblas"
#    fmod="I "
#    if [[ $real = r8 ]]; then
#        OPTPREC="$OPTPREC -fdefault-real-8 -DNC_DOUBLE -fcray-pointer"
#    fi
#    export F90FLAGS=" -ffree-form $OPTIMNC"
#    export FFLAGS=" $OPTIMNC"
#    export CC=gcc
#    export CXX=g++
#
#elif [[ $compiler = pgf90 ]]; then
#    OPTIM="-O2 -Mipa -Munroll -Mnoframe -Mautoinline -Mcache_align"
#    OPTDEB="-g -Mdclchk -Mbounds -Mchkfpstk -Mchkptr -Minform=inform -Mstandard -Ktrap=fp -traceback"
#    OPTDEV="-g -Mbounds -Ktrap=fp -traceback"
#    fmod="module "
#    if [[ $real = r8 ]]; then OPTPREC="$OPTPREC -r8 -DNC_DOUBLE"; fi
#    export CPPFLAGS="-DpgiFortran"
#    export CC=pgcc
#    export CFLAGS="-O2 -Msignextend"
#    export CXX=pgCC
#    export CXXFLAGS="-O2 -Msignextend"
#    export FFLAGS="-O2 $OPTIMNC"
#    export F90FLAGS="-O2 $OPTIMNC"
#    compile_with_fcm=1
#
#elif [[ $compiler = ifort || $compiler = mpiifort ]]; then
#    OPTIM="-O2 -fp-model strict -ip -align all "
#    OPTDEV="-p -g -O2 -traceback -fp-stack-check -ftrapuv -check"
#    OPTDEB="-g -no-ftz -traceback -ftrapuv -fp-stack-check -check"
#    fmod='module '
#    if [[ $real = r8 ]]; then OPTPREC="$OPTPREC -real-size 64 -DNC_DOUBLE"; fi
#    export CPP="icc -E"
#    export FFLAGS="-O2 -ip -fpic -mcmodel=large"
#    export FCFLAGS="-O2 -ip -fpic -mcmodel=large"
#    export CC=icc
#    export CFLAGS="-O2 -ip -fpic -mcmodel=large"
#    export CXX=icpc
#    export CXXFLAGS="-O2 -ip -fpic -mcmodel=large"
#    export fpp_flags="-P -traditional"
#    # Pourquoi forcer la compilation fcm. Marche mieux sans
#    #compile_with_fcm=1
#else
#    echo "unexpected compiler $compiler"; exit 1
#fi
#
#OPTIMGCM="$OPTIM $OPTPREC"




#============================================================================
veget_version=false
if [[ $veget != 'NONE' ]]; then
    cd "$MODEL/modipsl/modeles/ORCHIDEE"
    set +e; svn upgrade; set -e
    if [[ $veget = "CMIP6" ]]; then
        veget_version=orchidee2.0
        orchidee_rev=6592
    else # specific orchidee revision newer than CMIP6, on 2_1 or 2_2 branches
        veget_version=orchidee2.1
        orchidee_rev=$veget
        if [[ $veget -lt 4465 ]]; then
            echo 'Stopping, ORCHIDEE version too old, script needs work on ' \
                 'the CPP flags to pass to makelmdz'
            exit 1
        fi
        set +e
        # which branch is my version on?
        orcbranch=$(svn log -v -q svn://forge.ipsl.jussieu.fr/orchidee/ -r "$veget" |grep ORCHIDEE |head -1| sed -e 's:ORCHIDEE/.*$:ORCHIDEE:' | awk '{print $2}')
        # switch to that branch
        echo IF YOU INSTALL ORCHIDEE THE VERY FIRST TIME, ASK for PASSWORD at \
             orchidee-help@listes.ipsl.fr
        svn switch -r "$veget" --accept theirs-full "svn://forge.ipsl.jussieu.fr/orchidee/$orcbranch"
        if ! (svn log -r "$veget" | grep "$veget"); then
            echo 'Cannot update ORCHIDEE as not on the right branch for ORCHIDEE'
            exit 1
        fi
        set -e
        set +e; svn update -r "$veget"; set -e
    fi
    # Correctif suite debug Jean-Zay
    sed -i -e 's/9010  FORMAT(A52,F17.14)/9010  FORMAT(A52,F20.14)/' \
        src_stomate/stomate.f90
    opt_orc="-prod"; if [[ "$optim" = "-debug" ]]; then opt_orc="-debug"; fi

    orchideelog=$(pwd)/orchidee.log
    echo '########################################################'
    echo 'Compiling ORCHIDEE, the continental surface model '
    echo '########################################################'
    echo "Start of the first compilation of orchidee, in sequential mode: $(date)"
    echo "log file : $orchideelog"

    ORCHPATH=$(pwd)
    export ORCHPATH=$ORCHPATH
    xios_orchid="-noxios"
    if [[ "$with_xios" = "y" ]]; then
        xios_orchid="-xios"
    fi
    if [[ -d tools ]]; then
        ###################################################################
        # Pour les experts qui voudraient changer de version d'orchidee.
        # Attention : necessite d'avoir le password pour orchidee
        ###################################################################
        if [[ "$veget_version" == "false" ]]; then
            veget_version=orchidee2.0
        fi
        cd arch
        sed -e s:"%COMPILER        .*.$:%COMPILER            $compiler":1 \
            -e s:"%LINK            .*.$:%LINK                $compiler":1 \
            -e s:"%FPP_FLAGS       .*.$:%FPP_FLAGS           $fpp_flags":1 \
            -e s:"%PROD_FFLAGS     .*.$:%PROD_FFLAGS         $OPTIM":1 \
            -e s:"%DEV_FFLAGS      .*.$:%DEV_FFLAGS          $OPTDEV":1 \
            -e s:"%DEBUG_FFLAGS    .*.$:%DEBUG_FFLAGS        $OPTDEB":1 \
            -e s:"%BASE_FFLAGS     .*.$:%BASE_FFLAGS         $OPTPREC":1 \
            -e s:"%BASE_LD         .*.$:%BASE_LD             $BASE_LD":1 \
            -e s:"%ARFLAGS         .*.$:%ARFLAGS             $ARFLAGS":1 \
            arch-gfortran.fcm > arch-local.fcm
        cat <<EOF > arch-local.path
NETCDF_LIBDIR="-L$ncdfdir/lib -lnetcdff -lnetcdf"
NETCDF_INCDIR="$ncdfdir/include"
IOIPSL_INCDIR="$ORCHPATH/../../lib"
IOIPSL_LIBDIR="$ORCHPATH/../../lib"
XIOS_INCDIR="\$ORCHDIR/../XIOS/inc"
XIOS_LIBDIR="\$ORCHDIR/../XIOS/lib -lxios"
EOF
        cd ../

        echo ./makeorchidee_fcm -j $xios_orchid $opt_orc -parallel none \
             -arch $arch
        ./makeorchidee_fcm -j 8 $xios_orchid $opt_orc -parallel none \
                           -arch $arch > "$orchideelog" 2>&1
        pwd
    else # of "if [[ -d tools ]]"
        if [[ -d src_parallel ]]; then
            liste_src="parallel parameters global stomate sechiba driver"
            if [[ "$veget_version" == "false" ]]; then
                veget_version=orchidee2.0
            fi
        fi
        for d in $liste_src; do
            src_d=src_$d
            echo src_d "$src_d"
            echo ls; ls
            if [[ ! -d $src_d ]]; then
                echo "Problem orchidee : no $src_d"; exit 1
            fi
            cd "$src_d"; \rm -f -- *.mod make; $make clean
            $make > "$orchideelog" 2>&1
            if [[ "$compiler" = "gfortran" || "$compiler" = "mpif90" ]]; then
                cp -f -- *.mod ../../../lib
            fi
            cd ..
        done
    fi # of "if [[ -d tools ]]"
    echo "install_lmdz.sh orchidee_compil_seq_OK $(date)"
fi # of if [[ "$veget" != 'NONE' ]]


#============================================================================
# Ehouarn: the directory name LMDZ* depends on version/tar file...
if find . -name "$MODEL/modipsl/modeles/LMD*"; then
    echo '###############################################################'
    echo 'Preparing LMDZ compilation : arch file, svn switch if needed...'
    echo '###############################################################'
    cd "$MODEL/modipsl/modeles/"LMD*
    LMDZPATH=$(pwd)
else
    echo "ERROR: No LMD* directory !!!"
    exit 1
fi


###########################################################
# For those who want to use fcm to compile via :
#  makelmdz_fcm -arch local .....
############################################################



cd "$MODEL/modipsl/modeles"/LMDZ*
lmdzlog=$(pwd)/lmdz.log

##################################################################
# Possibly update LMDZ if a specific svn release is requested
##################################################################

set +e; svn upgrade; set -e

if [[ $svn = "last" ]]; then svnopt=""; else svnopt="-r $svn"; fi
if [[ $svn != "" ]]; then
    if set +e; svn info | grep -q 'https:'; then
        svn switch --relocate https://svn.lmd.jussieu.fr/LMDZ \
            http://svn.lmd.jussieu.fr/LMDZ
    fi
    svn update "$svnopt"
    set -e
fi

#---------------------------------------------------------------------
# Retrieve the final svn release number, and adjust compilation
# options accordingly
# If svn not available, will use the svn writen in $MODEL/Readm*md
# For old version it assumes that it is before 4185 (the version
# for which the test was introduced
#---------------------------------------------------------------------

set +e; mysvn=$(svnversion . | grep -E || "[0-9]+" 2>/dev/null); set -e
if [[ "$mysvn" = "" ]]; then mysvn=$(grep 'Revision: [0-9]' "$MODEL"/Read*.md | awk ' { print $2 } ' 2>/dev/null); fi
if [[ "$mysvn" = "" ]]; then mysvn=4190; fi

if [[ "$pclinux" = "1" && ! -f arch/arch-local.path ]]; then

    # create local 'arch' files (if on Linux PC):
    cd arch
    # arch-local.path file
    # test for version as arch.pth file changed format with rev 4426
    if [[ "$mysvn" -gt 4425 ]]; then
      cat <<EOF > arch-local.path
NETCDF_LIBDIR="-L$ncdfdir/lib"
NETCDF_LIB="-lnetcdff -lnetcdf"
NETCDF_INCDIR=-I$ncdfdir/include
NETCDF95_INCDIR=-I\$LMDGCM/../../include
NETCDF95_LIBDIR=-L\$LMDGCM/../../lib
NETCDF95_LIB=-lnetcdf95
IOIPSL_INCDIR=-I\$LMDGCM/../../lib
IOIPSL_LIBDIR=-L\$LMDGCM/../../lib
IOIPSL_LIB=-lioipsl
XIOS_INCDIR=-I\$LMDGCM/../XIOS/inc
XIOS_LIBDIR=-L\$LMDGCM/../XIOS/lib
XIOS_LIB="-lxios -lstdc++"
ORCH_INCDIR=-I\$LMDGCM/../../lib
ORCH_LIBDIR=-L\$LMDGCM/../../lib
EOF
    else
      cat <<EOF > arch-local.path
NETCDF_LIBDIR="-L$ncdfdir/lib -lnetcdff -lnetcdf"
NETCDF_INCDIR=-I$ncdfdir/include
NETCDF95_INCDIR=\$LMDGCM/../../include
NETCDF95_LIBDIR=\$LMDGCM/../../lib
IOIPSL_INCDIR=\$LMDGCM/../../lib
IOIPSL_LIBDIR=\$LMDGCM/../../lib
XIOS_INCDIR=\$LMDGCM/../XIOS/inc
XIOS_LIBDIR=\$LMDGCM/../XIOS/lib
ORCH_INCDIR=\$LMDGCM/../../lib
ORCH_LIBDIR=\$LMDGCM/../../lib
EOF
    fi 

    if [[ $pcmac == 1 ]]; then
        BASE_LD="$BASE_LD -Wl,-rpath,${ncdfdir}/lib"
    else
        BASE_LD="$BASE_LD -Wl,-rpath=${ncdfdir}/lib"
    fi
    # Arch-local.fcm file (adapted from arch-linux-32bit.fcm)

    if [[ $real = r8 ]]; then FPP_DEF=NC_DOUBLE; else FPP_DEF=""; fi
    sed -e s:"%COMPILER        .*.$:%COMPILER            $compiler":1 \
        -e s:"%LINK            .*.$:%LINK                $compiler":1 \
        -e s:"%PROD_FFLAGS     .*.$:%PROD_FFLAGS         $OPTIM":1 \
        -e s:"%DEV_FFLAGS      .*.$:%DEV_FFLAGS          $OPTDEV":1 \
        -e s:"%DEBUG_FFLAGS    .*.$:%DEBUG_FFLAGS        $OPTDEB":1 \
        -e s:"%BASE_FFLAGS     .*.$:%BASE_FFLAGS         $OPTPREC":1 \
        -e s:"%FPP_DEF         .*.$:%FPP_DEF             $FPP_DEF":1 \
        -e s:"%BASE_LD         .*.$:%BASE_LD             $BASE_LD":1 \
        -e s:"%ARFLAGS         .*.$:%ARFLAGS             $ARFLAGS":1 \
        arch-linux-32bit.fcm > arch-local.fcm

    cd ..
    ### Adapt "bld.cfg" (add the shell):
    #whereisthatshell=$(which ${use_shell})
    #echo "bld::tool::SHELL   $whereisthatshell" >> bld.cfg

fi # of if [[ "$pclinux" = 1 ]]
#---------------------------------------------------------------------
# Option de compilation du rayonnement : depend de $mysvn ><= r4185
#---------------------------------------------------------------------
opt_rad=""

case $rad in
    oldrad) iflag_rrtm=0; NSW=2; opt_rad="";;
    rrtm)   iflag_rrtm=1; NSW=6
            if [[ $mysvn -le 4185 ]]; then
                opt_rad="-rrtm true"
            else
                opt_rad="-rad rrtm"
            fi;;
    ecrad)  iflag_rrtm=2; NSW=6; opt_rad="-rad ecrad";;
    *) echo "Only oldrad rrtm ecrad for rad option"; exit 1
esac

if [[ $mysvn -le 4185 && $rad = "ecrad" ]]; then
    echo "ecrad only available for LMDZ rev starting with 4186 "; exit 1
fi

##################################################################


if [[ ! -f libf/misc/netcdf95.F90 &&  ! -d $MODEL/NetCDF95-0.3 ]]; then
    cd "$MODEL"
    myget src_archives/netcdf/NetCDF95-0.3.tar.gz
    tar -xf NetCDF95-0.3.tar.gz
    rm NetCDF95-0.3.tar.gz
    cd NetCDF95-0.3
    mkdir build
    cd build
    cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH="$ncdfdir" \
          -DCMAKE_INSTALL_PREFIX="$MODEL/modipsl"
    make install
    cd "$MODEL/modipsl/modeles/"LMDZ*
fi

echo '##################################################################'
echo "Preparing script compile.sh for LMDZ compilation"
echo "It will only be run automatically if bench=1/tuto"
echo "Here bench=$bench"
echo '##################################################################'

if [[ $env_file != "" ]]; then
    mv arch/arch-${arch}.env arch/arch-${arch}.orig
    \cp -f "$env_file" arch/arch-${arch}.env
fi

if [[ $compile_with_fcm = 1 ]]; then
    makelmdz="makelmdz_fcm $optim -arch $arch -j 8 "
else
    makelmdz="makelmdz $optim -arch $arch"
fi

# sequential compilation
if [[ "$sequential" = 1 ]]; then
    echo Sequential compilation command, saved in compile.sh:
    echo "./$makelmdz $optim $OPT_MAKELMDZ $optim $opt_rad $opt_cosp " \
         "-d ${grid_resolution} -v $veget_version gcm "
    echo "./$makelmdz $optim $OPT_MAKELMDZ $optim $opt_rad $opt_cosp " \
         "-d ${grid_resolution} -v $veget_version gcm " > compile.sh
    chmod +x ./compile.sh
    if [[ $bench = 1 ]]; then
        echo "install_lmdz.sh start_lmdz_seq_compilation $(date)"
        echo "log file: $lmdzlog"
        ./compile.sh > "$lmdzlog" 2>&1
        echo "install_lmdz.sh end_lmdz_seq_compilation $(date)"
    fi
fi # fin sequential

# compiling in parallel mode
if [[ $parallel != "none" ]]; then
    echo '##########################################################'
    echo ' Parallel compile '
    echo '##########################################################'
    echo "(after saving the sequential libs and binaries)"
    cd "$MODEL/modipsl"
    tar cf sequential.tar bin/ lib/
    #
    # Orchidee
    #
    cd "$ORCHPATH"
    if [[ -d src_parallel && $veget != 'NONE' ]]; then
        cd arch
        sed  \
            -e s:"%COMPILER.*.$:%COMPILER            $par_comp":1 \
            -e s:"%LINK.*.$:%LINK                $par_comp":1 \
            -e s:"%MPI_FFLAG.*.$:%MPI_FFLAGS          $MPI_FLAGS":1 \
            -e s:"%OMP_FFLAG.*.$:%OMP_FFLAGS          $OMP_FLAGS":1 \
            -e s:"%MPI_LD.*.$:%MPI_LD              $MPI_LD":1 \
            -e s:"%OMP_LD.*.$:%OMP_LD              $OMP_LD":1 \
            arch-local.fcm > tmp.fcm

        mv tmp.fcm arch-local.fcm
        cd ../
        echo "Compiling ORCHIDEE in parallel mode $(date)"
        echo "logfile $orchideelog"
        echo "NOTE : to recompile it when necessary, use ./compile_orc.sh " \
             "in modipsl/modeles/ORCHIDEE"
        echo ./makeorchidee_fcm -j 8 -clean $xios_orchid $opt_orc \
             -parallel "$parallel" -arch $arch > compile_orc.sh
        echo ./makeorchidee_fcm -j 8 $xios_orchid $opt_orc \
             -parallel "$parallel" -arch $arch >> compile_orc.sh
        echo echo Now you must also recompile LMDZ, by running ./compile.sh \
             in modeles/LMDZ >> compile_orc.sh
        chmod u+x compile_orc.sh
        ./makeorchidee_fcm -j 8 -clean $xios_orchid $opt_orc \
                           -parallel "$parallel" -arch $arch > "$orchideelog" 2>&1
        ./makeorchidee_fcm -j 8 $xios_orchid $opt_orc -parallel "$parallel" \
                           -arch $arch >> "$orchideelog" 2>&1
        echo "End of ORCHIDEE compilation in parallel mode $(date)"
    elif [[ $veget != 'NONE' ]]; then
        echo '##########################################################'
        echo ' Orchidee version too old                                 '
        echo ' Please update to new version                             '
        echo '##########################################################'
        exit 1
    fi #�of [ -d src_parallel && $veget != 'NONE' ]

    # LMDZ
    cd "$LMDZPATH"
    if [[ $arch = local ]]; then
        cd arch
        sed -e s:"%COMPILER.*.$:%COMPILER            $par_comp":1 \
            -e s:"%LINK.*.$:%LINK                $par_comp":1 \
            -e s:"%MPI_FFLAG.*.$:%MPI_FFLAGS          $MPI_FLAGS":1 \
            -e s:"%OMP_FFLAG.*.$:%OMP_FFLAGS          $OMP_FLAGS":1 \
            -e s:"%ARFLAGS.*.$:%ARFLAGS          $ARFLAGS":1 \
            -e "s§%BASE_LD.*.$§%BASE_LD             -Wl,-rpath=${root_mpi}/lib:${ncdfdir}/lib§1" \
            -e s:"%MPI_LD.*.$:%MPI_LD              $MPI_LD":1 \
            -e s:"%OMP_LD.*.$:%OMP_LD              $OMP_LD":1 \
            arch-local.fcm > tmp.fcm
        mv tmp.fcm arch-local.fcm
        cd ../
    fi
    rm -f compile.sh
    echo resol="$grid_resolution" >> compile.sh
    if [[ ${hostname:0:5} = jean- && "$cosp" = "v2" ]]; then

        echo "LMDZ compilation command in parallel mode, saved in compile.sh, is :"
        echo "(ATTENTION le probleme de cospv2 sur jean-zay en mode prod " \
             "n est pas corrige ! )"
        # ATTENTION le probleme de cospv2 sur jean-zay en mode prod n
        # est pas corrige
        echo ./"$makelmdz" -dev $optim "$OPT_MAKELMDZ" "$opt_rad" "$opt_cosp" \
             "$opt_makelmdz_xios" -d \$resol -v $veget_version -mem \
             -parallel "$parallel" gcm >> compile.sh
        echo ./"$makelmdz" -dev $optim "$OPT_MAKELMDZ" "$opt_rad" "$opt_cosp" \
             "$opt_makelmdz_xios" -d \$resol -v $veget_version -mem \
             -parallel "$parallel" gcm
    else
        echo ./"$makelmdz" $optim "$OPT_MAKELMDZ" "$opt_rad" "$opt_cosp" \
             "$opt_makelmdz_xios" -d \$resol -v $veget_version -mem \
             -parallel "$parallel" gcm >> compile.sh
        echo ./"$makelmdz" $optim "$OPT_MAKELMDZ" "$opt_rad" "$opt_cosp" \
             "$opt_makelmdz_xios" -d \$resol -v $veget_version -mem \
             -parallel "$parallel" gcm
    fi
    chmod +x ./compile.sh

    if [[ $bench = 1 ]]; then
        echo "Compiling LMDZ in parallel mode $(date),  LMDZ log file: $lmdzlog"
        ./compile.sh > "$lmdzlog" 2>&1
    fi

fi # of if [[ $parallel != "none" ]]


##################################################################
# Verification du succes de la compilation
##################################################################

# Recherche de l'executable dont le nom a change au fil du temps ...
# suffix contains radiative option starting with revision 4186
if [[ $mysvn -ge 4186 ]]; then suff_exe=_${rad}${suff_exe}; fi
gcm=""

for exe in gcm.e bin/gcm_${grid_resolution}_phylmd${suff_exe}${suff_orc}.e
do
    if [[ -f $exe ]]; then gcm=$exe; fi
done

if [[ "$gcm" = "" ]]; then
    if [[ $bench = 1 ]]; then
        echo 'Compilation failed !! Cannot run the benchmark;'
        exit 1
    else
        echo 'Compilation not done (only done when bench=1)'
    fi
else
    echo '##########################################################'
    echo "Compilation successfull !!  $(date)"
    echo '##########################################################'
    echo "The executable is $gcm"
fi

##################################################################
# Below, we run a benchmark if bench=1 or tuto
##################################################################

if [[ $bench = tuto ]]; then
    myget Training/tutorial.tar; tar xf tutorial.tar; cd TUTORIAL
    ./init.sh

elif [[ $bench = 1 && ! -d BENCH${grid_resolution} ]]; then
    # TOUTE CETTE SECTION DEVRAIT DISPARAITRE POUR UNE COMMANDE
    # OU DES BENCHS PAR MOTS CLES COMME tuto

    echo '##########################################################'
    echo ' Running a test run '
    echo '##########################################################'

    \rm -rf "BENCH${grid_resolution}"
    bench=bench_lmdz_${grid_resolution}
    echo "install_lmdz.sh before bench download  $(date)"
    #wget http://www.lmd.jussieu.fr/~lmdz/Distrib/$bench.tar.gz
    myget "3DBenchs/$bench.tar.gz"
    echo "install_lmdz.sh after bench download  $(date)"
    tar xf "$bench.tar.gz"

    if [[ "$cosp" = "v1" || "$cosp" = "v2" ]]; then
        cd "BENCH${grid_resolution}"
        # copier les fichiers namelist input et output our COSP
        cp ../DefLists/cosp*_input_nl.txt .
        cp ../DefLists/cosp*_output_nl.txt .
        # Activer la cles ok_cosp pour tourner avec COSP
        sed -e 's@ok_cosp=n@ok_cosp=y@' config.def > tmp
        \mv -f tmp config.def
        cd ..
    fi

    if [[ -n "$physiq" ]]; then
        cd "BENCH${grid_resolution}"
        if [[ -f "physiq.def_${physiq}" ]]; then
            cp "physiq.def_${physiq}" physiq.def
            echo using "physiq.def_${physiq}"
        else
            echo using standard physiq.def
        fi
        cd ..
    else
        echo using standard physiq.def
    fi

    if [[ "$with_xios" = "y" ]]; then
        cd "BENCH${grid_resolution}"
        cp ../DefLists/iodef.xml .
        cp ../DefLists/context_lmdz.xml .
        cp ../DefLists/field_def_lmdz.xml .
        # A raffiner par la suite
        echo "A FAIRE : Copier les *xml en fonction de l option cosp"
        cp ../DefLists/field_def_cosp*.xml .
        cp ../DefLists/file_def_hist*xml .
        # adapt iodef.xml to use attached mode
        sed -e 's@"using_server" type="bool">true@"using_server" type="bool">false@' \
            iodef.xml > tmp
        \mv -f tmp iodef.xml

        # and convert all the enabled="_AUTO_" (for libIGCM) to enabled=.FALSE.
        # except for histday
        for histfile in file_def_hist*xml
        do
            if [[ "$histfile" = "file_def_histday_lmdz.xml" ]]; then
                sed -e 's@enabled="_AUTO_"@type="one_file" enabled=".TRUE."@' \
                    "$histfile" > tmp
                \mv -f tmp "$histfile"
                sed -e 's@output_level="_AUTO_"@output_level="5"@' "$histfile" \
                    > tmp
                \mv -f tmp "$histfile"
                sed -e 's@compression_level="2"@compression_level="0"@' \
                    "$histfile" > tmp
                \mv -f tmp "$histfile"
            else
                sed -e 's@enabled="_AUTO_"@type="one_file" enabled=".FALSE."@' \
                    "$histfile" > tmp
                \mv -f tmp "$histfile"
            fi
        done
        # and add option "ok_all_xml=y" in config.def
        echo "### XIOS outputs" >> config.def
        echo 'ok_all_xml=.true.' >> config.def

        #activer les sorties pour Cosp
        if [[ "$cosp" = "v1" ]]; then
            sed -i'' -e 's@enabled=".FALSE."@enabled=".TRUE."@' \
                     -e 's@output_level="_AUTO_"@output_level="5"@' \
                     -e 's@compression_level="2"@compression_level="0"@' \
                     file_def_histdayCOSP_lmdz.xml
        fi
        if [[ "$cosp" = "v2" ]]; then
            sed -e 's@compression_level="2"@compression_level="0"@' file_def_histdayCOSPv2_lmdz.xml
            for type_ in hf day mth; do
                file=file_def_hist${type_}COSP
                sed -i'' -e 's@src="./'${file}'_lmdz.xml"@src="./'${file}'v2_lmdz.xml"@' context_lmdz.xml
            done
            sed -i '' -e 's@field_def_cosp1.xml@field_def_cospv2.xml@' field_def_lmdz.xml
        fi

        cd ..
    fi

    # Cas Bensh avec ecrad
    if [[ "$rad" = "ecrad" ]]; then
        cd "BENCH${grid_resolution}"
        cp  ../DefLists/namelist_ecrad .
        cp -r ../libf/phylmd/ecrad/data .
        cd ..
    fi

    # Adjusting bench physiq.def to radiative code chosen
    cd "BENCH${grid_resolution}"
    sed -e 's/iflag_rrtm=.*.$/iflag_rrtm='$iflag_rrtm'/' \
        -e 's/NSW=.*.$/NSW='$NSW'/' physiq.def > tmpdef
    \mv tmpdef physiq.def
    cd ..

    cp "$gcm" "BENCH${grid_resolution}/gcm.e"

    cd "BENCH${grid_resolution}"
    # On cree le fichier bench.sh au besoin
    # Dans le cas 48x36x39 le bench.sh existe deja en parallele

    if [[ "$grid_resolution" = "48x36x39" ]]; then
        echo On ne touche pas au bench.sh
        # But we have to adapt "run_local.sh" for $mpirun
        sed -e "s@mpirun@$mpirun@g" run_local.sh > tmp
        mv -f tmp run_local.sh
        chmod u=rwx run_local.sh
    elif [[ "${parallel:0:3}" = "mpi" ]]; then
        # Lancement avec deux procs mpi et 2 openMP
        echo "export OMP_STACKSIZE=800M" > bench.sh
        if [[ "${parallel:4:3}" = "omp" ]]; then
            echo "export OMP_NUM_THREADS=2" >> bench.sh
        fi
        if [[ "$cosp" = "v1" || "$cosp" = "v2" ]]; then
            if [[ ${hostname:0:5} = jean- ]]; then
                   chmod +x ../arch.env
                ../arch.env        
                echo "ulimit -s 2000000" >> bench.sh
            else
                echo "ulimit -s 200000" >> bench.sh
            fi        
        else
            echo "ulimit -s unlimited" >> bench.sh
        fi
        if [[ ${hostname:0:5} = jean- ]]; then
            . ../arch/arch-${arch}.env
            echo "srun -n 2 && $idris_acct@cpu gcm.e > listing  2>&1" \
                 >> bench.sh
        else
            echo "$mpirun -np 2 gcm.e > listing  2>&1" >> bench.sh
        fi
        # Add rebuild, using reb.sh if it is there
        cat <<EOF >> bench.sh
if [[ -f reb.sh ]]; then
  ./reb.sh histday; ./reb.sh histmth; ./reb.sh histhf;
  ./reb.sh histins; ./reb.sh stomate_history;
  ./reb.sh sechiba_history; ./reb.sh sechiba_out_2
fi
EOF
    else
        echo "./gcm.e > listing  2>&1" > bench.sh
    fi
    # Getting orchidee stuff
    if [[ $veget == 'CMIP6' ]]; then
        #echo 'myget 3DBenchs/BENCHorch11.tar.gz'
        #myget 3DBenchs/BENCHorch11.tar.gz
        #tar xvzf BENCHorch11.tar.gz
        echo 'myget 3DBenchs/BENCHCMIP6.tar.gz'
        myget 3DBenchs/BENCHCMIP6.tar.gz
        tar xvzf BENCHCMIP6.tar.gz
        sed -e "s:VEGET=n:VEGET=y:" config.def > tmp
        mv -f tmp config.def
        if [[ "$with_xios" = "y" ]]; then
            cp ../../ORCHIDEE/src_xml/context_orchidee.xml .
            echo '<context id="orchidee" src="./context_orchidee.xml"/>' \
                 > add.tmp
            cp ../../ORCHIDEE/src_xml/field_def_orchidee.xml .
            cp ../../ORCHIDEE/src_xml/file_def_orchidee.xml .
            cp ../../ORCHIDEE/src_xml/file_def_input_orchidee.xml .
            if [[ -f ../../ORCHIDEE/src_xml/context_input_orchidee.xml ]]; then
                   cp ../../ORCHIDEE/src_xml/context_input_orchidee.xml .
                   echo '<context id="orchidee" ' \
                     'src="./context_input_orchidee.xml"/>' >> add.tmp
            fi
            sed -e '/id="LMDZ"/r add.tmp' iodef.xml > tmp
            mv tmp iodef.xml
            sed -e'{/sechiba1/ s/enabled="_AUTO_"/type="one_file" enabled=".TRUE."/}' \
                file_def_orchidee.xml > tmp
            \mv -f tmp file_def_orchidee.xml
            sed -e 's@enabled="_AUTO_"@type="one_file" enabled=".FALSE."@' \
                file_def_orchidee.xml > tmp
            \mv -f tmp file_def_orchidee.xml
            sed -e 's@output_level="_AUTO_"@output_level="1"@' \
                file_def_orchidee.xml > tmp
            \mv -f tmp file_def_orchidee.xml
            sed -e 's@output_freq="_AUTO_"@output_freq="1d"@' \
                file_def_orchidee.xml > tmp
            \mv -f tmp file_def_orchidee.xml
            sed -e 's@compression_level="4"@compression_level="0"@' \
                file_def_orchidee.xml > tmp
            \mv -f tmp file_def_orchidee.xml
            sed -e 's@XIOS_ORCHIDEE_OK = n@XIOS_ORCHIDEE_OK = y@' \
                orchidee.def > tmp
            \mv -f tmp orchidee.def
        fi
    fi

    if [[ -f ../arch.env ]]
    then
        source ../arch.env
    fi

    echo EXECUTION DU BENCH
    set +e
    date; ./bench.sh > out.bench 2>&1; date
    set -e
    tail listing


    echo "##########################################################"
    echo "Simulation finished in $(pwd)"
    echo "You have compiled with:"
    cat ../compile.sh
    if [[ $parallel = "none" ]]; then
        echo "You may re-run it with : cd  $(pwd) ; gcm.e"
        echo "or ./bench.sh"
    else
        echo "You may re-run it with : "
        echo "cd  $(pwd) ; ./bench.sh"
        #  echo 'ulimit -s unlimited'
        #  echo 'export OMP_NUM_THREADS=2'
        #  echo 'export OMP_STACKSIZE=800M'
        #  echo "$mpirun -np 2 gcm.e "
    fi
    echo '##########################################################'

fi # bench


#################################################################
# Installation eventuelle du 1D
#################################################################

if [[ $SCM = 1 ]]; then
    cd "$MODEL"
    myget 1D/1D.tar.gz
    tar xf 1D.tar.gz
    cd 1D
    if [[ $rad = oldrad ]]; then
        sed -i'' -e 's/^rad=.*$/rad=oldrad/' run.sh
        sed -i'' -e 's/^rad=.*$/rad=oldrad/' bin/compile
    fi
    echo "Running 1D/run.sh, log in $(pwd)/run1d.log"
    ./run.sh > "$(pwd)/run1d.log" 2>&1
fi


#################################################################
# sauvegarde des options veget pour utilisation eventuelle tutorial_prod
#################################################################
cd "$MODEL/modipsl/modeles"
#echo surface_env file created in $MODEL
cat <<EOF >surface_env
veget=$veget
opt_veget="-v $veget_version"
orchidee_rev=$orchidee_rev
suforch=$suff_orc
EOF
