source: TOOLS/SURPACK_IPSL/launch_ipsl_pack.sh @ 3624

#!/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=
Question=n
continuePack=y
while [ $# -gt 0 ]
do
    echo "boucle sur les arguments du script ..."
    echo "@=$@"
    case $1 in
        -h)  cat <<fin
ce script permet de trouver une frequence de pack plus longue pour une simulation donnee
IMPORTANT : avant de lancer ce script vous devez configurer le fichier load_ipslPack_env.sh

Usage : ./launch_ipsl_pack.sh param.txt 
avec param.txt contenant le path de la simulation. Ex : 
vi param.txt ; /ccc/store/cont003/dsm/p86cozic/IGCM_OUT/IPSLCM5A/PROD/historical/CM51989.2
ATTENTION : il ne faut pas de "/" en fin du path

options de lancement : 
-h : manuel d'utilisation 
-f : possibilite de forcer le redemarrage du script au debut   
-v : mode dans lequel apres le calcul de la nouvelle frequence, le script propose a l'utilisateur
    de continuer ou non (donc de creer les nouvelles listes de fichiers à packer ou non) 

fin
            exit;;
        -f)  execEveryStep=1 
            echo "force..."
            ;;
        -v)  Question=y
            echo "nous nous arreterons apres le calcul de la frequence pour vous laisser le choix de continuer ou non"
            ;;
        *)  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
    echo "Vous devez passer un fichier en parametre"
    exit 1
else
    LISTE_SIMUL=${LISTE_SIMUL_ARG}
fi

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


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}
        freq=$(cat ${IGCM_DEM_SIMU}/period_pack.txt)
        if [[ "$Question" == "y" ]]; then 
            echo -e "L'outil de surpack vous propose une nouvelle frequence de pack de :  ${freq} annees "
            echo -e "voulez vous continuer ? "
            echo -n "(y/n) ? "
            read ContinueAnswer
            case ${ContinueAnswer} in      
                oui|OUI|o|y|yes|YES)
                    echo "OK nous continuons"
                    continuePack=y
                    ;;
                non|NON|n|no|NO)
                    echo "OK nous arretons tout"
                    continuePack=n
                    ;;
                *)
                    echo "I did not recognize your answer."
                    echo "Please respond: oui|OUI|o|y|yes|YES"
                    echo "Or please respond: non|NON|n|no|NO"
                    exit
                    ;;
            esac
        fi
        
        if [[ "$continuePack" == "y" ]] ; then 
            ${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
            
    fi
done
####################################################################

DEM_log -0 "Fin de ${SCRIPT_NAME}"