source: TOOLS/SURPACK_IPSL/launch_ipsl_pack.sh @ 2141

#!/bin/bash
######################
## TITANE   CEA ##
######################
#MSUB -r ipsl_pack      # Nom du job                
#MSUB -eo
#MSUB -n 1              # Reservation du processus
#MSUB -T 86400          # Limite de temps elapsed du job
#MSUB -p gen2211
#MSUB -q mono

# ex : ./launch_ipsl_pack.sh fichier_param_test1.txt
# ex : ./launch_ipsl_pack.sh param_SL.txt
# ex : ./launch_ipsl_pack.sh param_OM.txt

# Est-on sur ulam (machine de l'IDRIS) ?
is_idris_machine=`hostname | grep "ulam" | wc -l `
ON_IDRIS="no"
if [ "x${is_idris_machine}" != "x0" ]
then
    ON_IDRIS="yes"
fi
export ON_IDRIS=${ON_IDRIS}

##### gpdebug : addition ##################################
# Boucle qui gere les parametres du script (permet l'introduction d'une option -f 
# qui force l'execution de toute les etapes du script de listes)
execEveryStep=0
LISTE_SIMUL_ARG=
while [ $# -gt 0 ]
do
   echo "boucle sur les arguments du script ..."
   echo "@=$@"
   case $1 in
   -f)  execEveryStep=1 
        echo "force..."
        ;;
   *)  LISTE_SIMUL_ARG=${1} 
       echo "autres..."
       ;;
   esac
   shift
done
export execEveryStep=${execEveryStep}

SCRIPT_NAME=$(basename ${0} )

# On renseigne les variables d'environnement
export scriptCallingLoad=$SCRIPT_NAME # sert a renseigner "load_ipslPack_env.sh" sur le script l'appelant
. load_ipslPack_env.sh

if [ "x${LISTE_SIMUL_ARG}" == "x" ]
then
    if [ -f /ccc/work/cont003/dsm/p86ipsl/PARAM_USER_IPSL/$USER.txt ]
    then
        echo "The file used is /ccc/work/cont003/dsm/p86ipsl/PARAM_USER_IPSL/$USER.txt" 
        LISTE_SIMUL="/ccc/work/cont003/dsm/p86ipsl/PARAM_USER_IPSL/$USER.txt" 
    else        
        echo "Vous devez passer un fichier en parametre"
        exit 1
    fi
else
    LISTE_SIMUL=${LISTE_SIMUL_ARG}
fi

LISTE_SIMUL_NAME=$(basename ${LISTE_SIMUL} )
# fichier de progression d'execution
ficParam=$( basename ${LISTE_SIMUL} ) # gpdebug : modif ici et ligne d'apres
extSuiviListes=`echo ${ficParam} | sed 's;\.[[:alnum:]]*$;;' `

##### gpdebug : fin #####################################

export JOB_DIR=${TMP_MIGR_DATA}
export EXE_DIR=${LS_SUBCWD:-${PWD}}

export MonitoringDir="${TMP_MIGR_DATA}/SuiviListes_${extSuiviListes}"

export generalMonitorFile=${MonitoringDir}/general.txt
export nbSimuFile=${MonitoringDir}/nbSimu.txt


if [ "x${IGCM_DEM}" == "x" ]
then
    echo "variable IGCM_DEM non renseignee. STOP."
    exit 1
fi
if [ "x${execEveryStep}" == "x1" ]
then
    echo "Destruction du repertoire :"
    echo "${IGCM_DEM}"
    rm -rf ${IGCM_DEM}
fi

export IGCM_TMP="${IGCM_DEM}/tmp" 
# INPUT_DMF_DATA, positionnee par le load_ipslPack_env.sh, sert pour pour PATH_SIMUL_SHORT dans create_config_card.sh

export clean_tmp=${clean_tmp:-yes}
export DEM_LOG=${JOB_DIR}/dem_${LSB_JOBID:-${$}}.log
export LOG_LEV=0
export FileParam=${LISTE_SIMUL} # gpdebug : pour appel (dans DEM_utilities.sh) a showListsProgress.sh
export FatherPID=$$ # gpdebug : pour appel (dans DEM_utilities.sh) a showListsProgress.sh

source ${EXE_DIR}/DEM_utilities.sh

# gpdebug : prepare le fichier de suivi de la progression
prepareMonitoringDir

# gpdebug : Execute la function errorReceive() si reception d'un signal TERM
trap 'DEM_errorReceive' TERM ########

# gpdebug : liste des processus à détruire en cas d'erreur bloquante
export listPID=$$ ########

# gpdebug : fichier pour la transmission des messages d'erreur d'un fils au prog principal
export errorMsgFile="${TMP_MIGR_DATA}/errorMsg.txt" ########

DEM_log -0 "Demarrage de ${SCRIPT_NAME}"

mkdir -p ${IGCM_DEM}
mkdir -p ${IGCM_TMP}

rm -rf ${IGCM_TMP}/tmp/*
rm -f ${DEM_LOG}

# 0- on cree le listing correspondant au fichier param 
# on efface les tests precedents

for DIR in $( awk '{print $0}' ${LISTE_SIMUL} ) ; do
    eval DIR_FINAL=$DIR
    ./create_listing.sh $DIR_FINAL
done

LISTE_DMNFS=${IGCM_DEM}/Listing.txt


# 1- A partir de param_list - on recherche l'ensemble des simulations a packer
# la liste creee (liste_simul_$1) est stockee dans $SCRATCHDIR/IGCM_DEM

${EXE_DIR}/find_directory_simul.sh ${LISTE_SIMUL} ${LISTE_DMNFS}


# 2- Pour chacune des simulations listees on cree un fichier config.card correspondant
# ces fichiers seront stockes dans ${IGCM_DEM}/arborescence/
# un fichier recapitulatif des fichiers config.card (config_card.liste) crees sera stocke dans ${IGCM_DEM}

${EXE_DIR}/create_config_card.sh ${IGCM_DEM}/liste_simul_${LISTE_SIMUL_NAME}  ${LISTE_DMNFS}

#3- recherche de la taille ideale de pack pour chacune des simulations - puis creation des listes

for CONFIG in $( awk '{print $1}' ${IGCM_DEM}/config_card.liste ) ; do 
    DEM_log -2 ${CONFIG}

    eval $(grep IGCM_DEM_SIMU ${CONFIG})
    ${EXE_DIR}/calcul_size_simul.sh ${CONFIG} ${LISTE_DMNFS}

    DEM_state=$( DEM_read_state ${IGCM_DEM}/config_card.liste ${CONFIG} )
    if [[ "${DEM_state}" != "WriteListTarDone" ]] ; then

        DEM_log -3  "la simulation est superieur a 1Go alors on pack"
        ${EXE_DIR}/find_size_pack.sh   ${CONFIG} ${LISTE_DMNFS}
        ${EXE_DIR}/write_liste_pack.sh ${CONFIG} ${LISTE_DMNFS}
        ${EXE_DIR}/archive_restart.sh ${CONFIG} ${LISTE_DMNFS}
        ${EXE_DIR}/archive_debug.sh ${CONFIG} ${LISTE_DMNFS}

    fi
done
####################################################################

DEM_log -0 "Fin de ${SCRIPT_NAME}"