run_raw2l1.sh

#!/bin/bash

#==============================================================================
# moy1min.sh
#
#   Ce script sert à faire l'interface entre le traitement a qui calcule
# les moyennes 1 minutes des données radflux en zone 2 et le traitement b qui
# prend en charge le contrôle qualité des données.
#
#   Le traitement a en plus des moyennes 1 min calcule aussi la valeur minnimum
# et maximum utilisé pour calculer la moyenne et fourni l'écart-type
#
#   Le traitement b permet soit de faire un contrôle qualité automatique soit
# d'utiliser un fichier de contrôle qualité généré par un opérateur pour filtrer
# les données
#
# Parametres d'entree :
#----------------------
#   -h : Affiche l'aide
#   -v : Affiche la version du script
#   -d : Date a traiter (format AAAAMMJJ)
#   -e : Fichier contenant la liste des fichiers d'entree
#   -s : Fichier contenant la liste des fichiers de sortie
#   -c : Nom du fichier de configuration
#   -n : Niveau de deboggage
#   -t : Repertoire de travail
#
# Historique :
#-------------
#   20161206 : MAD SIRTA Creation v1.00
#   20170220 : MAD SIRTA add configuration for P7. use submodule for raw2l1
#            : v1.0.1 correct problem with path of configuration file
#            : v1.0.2 correct source for LISA configuration file
#   20170303 : v1.0.3 add material to process 3s SIRTA CL31 data
#            : v1.0.4 correct several bugs in 3s script and make 30s script more robust
#   20180523 : v1.0.5 use a more generic way to get the python interpreter
#   20180913 : v1.0.6 add configuration file for CEREA CL51
#   20190206 : v1.0.9 add configuration file for CEREA CL51 in jussieu
#
# SIRTA 2013
#==============================================================================

#==============================================================================
# usage
#
#   Cette fonction decrit l'utilisation et les parametres d'entree du script
#==============================================================================
function usage {
  echo -n "Utilisation de $NOM_PRGM : $NOM_PRGM [-h|-v] -d date -e liste_fich_entree "
  echo -n "[[-e liste_fich_basse_entree]...] -s liste_fich_sortie -t rep_travail "
  echo -n "-n niv_debogage"
  echo
  echo -e "  -d\tseules les donnees appartenant a cette date sont selectionnees,"
  echo -e "  \tle format de la date est du type aaaammjj"
  echo -e "  -e\tliste des fichiers niveau 1 5s ou 1s"
  echo -e "  -s\tliste des fichiers niveau 1 1min a creer"
  echo -e "  -n\tniveau de debogage (0 a 3)"
  echo -e "  -v\taffiche la version du programme"
  echo -e "  -c\tfichier de configuration"
  echo -e "  -h\taffiche cette aide"
  echo "Les fichiers a convertir doivent respecter la convention de nommage SIRTA."
}

#==============================================================================
# consignerMsg
#
#   Enregistre les messages dans un fichier de log et les affiche sur la sortie
# standard. La variable globale ENTETE_MSG peut etre initialisee avant l'appel.
# Le message n'est affiche que si son numero de debugage est inferieur ou egale
# a celui contenu dans la variable d'environnement DEBUG
# $1 : message
# $2 : niveau de debogage
#==============================================================================

function consignerMsg {
  local heure=$(date +%d/%m/%Y,%H:%M:%S)
  local niv_deb=$2

  if [[ $# -gt 2 ]]; then
    consignerMsg "consignerMsg attend au maximum deux arguments"
    return 1
  fi
  [[ -z $niv_deb || $niv_deb -lt 0 ]] && niv_deb=0
  if [[ $niv_deb -le $DEBUG ]]; then
    if [[ -n "$ENTETE_MSG" ]]; then
      echo "$heure, $ENTETE_MSG : $1"
    else
      echo "$heure, $1"
    fi
  fi
}

################################################################################
#
#                           Debut du script
#
################################################################################

NOM_PRGM=$(basename $0)
ENTETE_MSG=$NOM_PRGM
ERREUR=0
DEBUG=0
VERSION=1
REP_SOURCES=$(dirname $(readlink -f $0))

n=0

#------------------------------------------------------------------------------
# Recupere les parametres de la lignes de commande
#------------------------------------------------------------------------------
UNZIP=0
while getopts :d:e:s:t:n:c:a:uhv option; do
  case $option in
  d) date="$OPTARG" ;;
  h)
    usage
    exit 0
    ;;
  v)
    echo $VERSION
    exit 0
    ;;
  e)
    liste_entree[n]="$OPTARG"
    let n++
    ;;
  s) liste_sortie=${OPTARG} ;;
  t) REP_TRAVAIL=${OPTARG} ;;
  n) DEBUG=${OPTARG} ;;
  c) fich_conf="$OPTARG" ;;
  u) UNZIP=1 ;;
  a) fich_type="$OPTARG" ;; # SIRTA ou MF (format change legerement selon le logiciel d'acquisition)
  # permet de sauter des options inconnues sans sortir de while
  ?) while [[ $OPTIND -le $# && ${!OPTIND:0:1} != '-' ]]; do OPTIND=$((OPTIND + 1)); done ;;
  *) ERREUR=1 ;;
  esac
done

# RAW2L1 needed path
PYTHON="/usr/bin/env python3"
RAW2L1=${REP_SOURCES}"/sirta-raw2l1/raw2l1/raw2l1.py"
RAW2L1_CONF=${REP_SOURCES}"/"$fich_conf
RAW2L1_LOGS=${REP_SOURCES}"/logs/raw2l1.log"

NCKS="/usr/bin/ncks"

# CL parameters
# ----------------------------------------------------------------------------
# number of vertical gates
declare -A CL_N_GATES
CL_N_GATES["1"]=770
CL_N_GATES["2"]=385
CL_N_GATES["3"]=1500
CL_N_GATES["4"]=770
CL_N_GATES["6"]=1540
# number of characters per gate
N_CHAR_GATES=5

#------------------------------------------------------------------------------
# verification des parametres
#------------------------------------------------------------------------------
if [[ $ERREUR != 0 ]]; then
  usage
  exit 1
fi

if [[ $fich_type != "SIRTA" && $fich_type != "MF" ]]; then
  echo "Le type de fichier doit etre SIRTA, MF"
  exit 1
fi

let n--
while [[ $n -ge 0 ]]; do
  if [[ -z ${liste_entree[n]} ]]; then
    consignerMsg "Il faut indiquer la liste des fichiers d'entree a traiter."
    exit 1
  fi
  if [[ ! -f ${liste_entree[n]} ]]; then
    consignerMsg "La liste de fichiers d'entree ${liste_entree[n]} est vide ou n'existe pas."
    exit 1
  fi
  let n--
done

if [[ -z $liste_sortie ]]; then
  consignerMsg "Il faut indiquer la liste des fichiers de sortie a creer."
  exit 1
fi

if [[ ! -f $liste_sortie || ! -s $liste_sortie ]]; then
  consignerMsg "La liste de fichiers de sortie $liste_sortie est vide ou n'existe pas."
  exit 1
fi

if [[ -z $REP_TRAVAIL ]]; then
  consignerMsg "Il faut indiquer un repertoire de travail."
  exit 1
fi

if [[ ! -d $REP_TRAVAIL ]]; then
  consignerMsg "Le repertoire de travail $REP_TRAVAIL n'existe pas."
  exit 1
fi

#------------------------------------------------------------------------------
#       Traitement
#------------------------------------------------------------------------------

# Recuperation des fichiers d entree radflux
# On verifie d'abord si le fichier 1s existe si il n'existe pas on cherche le 5s
# Si on n'en trouve aucun on quitte
#------------------------------------------------------------------------------
n=0
while read l; do
  fich_entree[n]=$l
  let n++
done <${liste_entree[0]}

# test pour savoir si fichier du jour disponible
if [[ ${#fich_entree[*]} -lt 2 ]]; then
  consignerMsg "Pas de fichier du jour a traiter"
  exit 1
fi

# if unzipping raw files is needed
#------------------------------------------------------------------------------
if [[ $UNZIP == 0 ]]; then
  input_files=("${fich_entree[@]}")
elif [[ $UNZIP == 1 ]]; then
  consignerMsg "Désarchivage de l'archive"
  # create tmp directory for data
  tmp_data=$(mktemp -d -p "$REP_TRAVAIL")

  # unzip input files in it
  for zip_file in "${fich_entree[@]}"; do
    unzip "$zip_file" -d "$tmp_data"
  done

  # put all unzipped files in array
  mapfile -t input_files < <(find "$tmp_data" -name "*.dat" | sort)
fi

# check format of data message
#------------------------------------------------------------------------------
# create temp directory for data
tmp_check=$(mktemp -d -p "$REP_TRAVAIL")

consignerMsg "Vérification des données brutes"
for file_ in "${input_files[@]}"; do

  # check if empty line in input list
  if [[ -z $file_ ]]; then
    continue
  fi

  tmp_file_=$(basename "$file_")
  cl31_cor="$tmp_check/${tmp_file_%.*}.cor"

  # get vertical resolution of data
  vertical_conf=$(sed -nr '0,/CL/s/.*CL.*([0-9]).*/\1/p' "$file_")
  n_gates=${CL_N_GATES[$vertical_conf]}
  prof_n_chars=$((n_gates * N_CHAR_GATES))
  prof_n_chars_p1=$((prof_n_chars + 1))

  consignerMsg "number of vertical gates: $n_gates"

  case $fich_type in
  "SIRTA")
    awk --posix -v cl31_cor="$cl31_cor" -v prof_n_chars="$prof_n_chars" -v prof_n_chars_p1="$prof_n_chars_p1" '\
      BEGIN {l=1;p=0;e=0;printf "" > cl31_cor}
      NR<3 {print $0 >> cl31_cor;next}
      l==1 {if ($0 ~ /^[[:cntrl:]]*$/ || $0 ~ "File") {next}}
      l==1 {if ($0 ~ /^-[0-9-]{10} [0-9:]{8}.?$/) {l++;bloc=$0;e=0;next} else if (e==1) {next} else e=1}
      l==2 {if ($0 ~ /^[\001]CL.{6}[\002].?$/) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==3 {if (NF==5) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==4 {if (NF==10) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==5 {if (NF==10) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==6 {if (length($0) == prof_n_chars || length($0) == prof_n_chars_p1) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==7 {if ($0 ~ /^[\003][0-9a-z]{4}[\004].?$/) {p=1;bloc=bloc"\n"$0} else e=1}
      p==1 {printf bloc"\n" >> cl31_cor;l=1;p=0}
      e==1 {err++;print NR;l=1}
      END {if ($0 ~ "File") printf "\n%s\n",$0>>cl31_cor; if (err>0)print "err=",err}' "$file_"
    ;;
  "MF")
    awk --posix -v cl31_cor="$cl31_cor" -v prof_n_chars="$prof_n_chars" -v prof_n_chars_p1="$prof_n_chars_p1" '\
      BEGIN {l=1;p=0;e=0;printf "" > cl31_cor}
      l==1 {if ($0 ~ /^[\001]$/) {l++;bloc=$0;e=0;next} else if (e==1) {next} else e=1}
      l==2 {if ($0 ~ /^-[0-9-]{10} [0-9:]{8}$/) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==3 {if ($0 ~ /^ CL.{6}[\002].$/) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==4 {if (NF==5) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==5 {if (NF==10) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==6 {if (NF==10) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==7 {if (length($0) == prof_n_chars || length($0) == prof_n_chars_p1) {l++;bloc=bloc"\n"$0;next} else e=1}
      l==8 {if ($0 ~ /^[\003][0-9a-z]{4}[\004].$/) {p=1;bloc=bloc"\n"$0} else e=1}
      p==1 {printf bloc"\n" >> cl31_cor;l=1;p=0}
      e==1 {err++;print NR;l=1}
      END {if ($0 ~ "File") printf "\n%s\n",$0>>cl31_cor; if (err>0)print "err=",err}' "$file_"
    ;;
  esac
done

mapfile -t input_files < <(find "$tmp_check" -name "*.cor" | sort)

# Recuperation des fichiers de sortie
#------------------------------------------------------------------------------
fich_sortie=$(cat "$liste_sortie")

# fichier temporaire
tmpfile=$(mktemp "$REP_TRAVAIL"/test_XXXXX.nc)

# conversion avec raw2l1
#------------------------------------------------------------------------------
cmd="$PYTHON $RAW2L1 '$date' $RAW2L1_CONF ${input_files[*]} $tmpfile -log $RAW2L1_LOGS -v info"

eval $cmd

if [[ $? == 0 ]]; then
  # suppression des donnees qui ne correspondent pas au jour
  #-------------------------------------------------------------------------
  date_as_days=$(bc -l <<<"$(date -u -d "$date" +%s)/86400")
  date_p1=$(bc -l <<<"($(date -u -d "$date" +%s)+86399)/86400")

  cmd="$NCKS -h -O -d time,${date_as_days},${date_p1} $tmpfile $fich_sortie"

  consignerMsg "suppression des données n'appartenant au jour traite"
  eval $cmd
else
  \rm "$tmpfile"

  if [[ $UNZIP == 1 ]]; then
    \rm -rf "$tmp_data"
  fi

  exit 1
fi

\rm "$tmpfile"
# if needed remove unzipped files
if [[ $UNZIP == 1 ]]; then
  \rm -rf "$tmp_data"
fi

\rm -rf "$tmp_check"

if (($? > 1)); then
  exit 1
fi

exit 0