#################################################################################################
#
# File
#
#   functions.sh
#
# Contenuto
#
#   definizione delle funzioni utilizzate nella costruzione dell'ambiente necessario alle
#   elaborazioni dei dati ibis
#
#################################################################################################

#################################################################################################
#
# checkForDataQuality()
#
#    Controlla la qualita' dei dati, in particolare verifica che ogni scw:
#      - contenga almeno i tre file compton_events.fits.gz, isgri_events.fits.gz e swg.fits
#      - che ognuno di tali file si conforme allo standard fits
#
# Parametri
#
#    listOfScwsAbsolutePath:       path assoluto del file delle science window
#    workingDirectoryAbsolutePath: path assoluto della directory di lavoro
#    exeLogAbsolutePath:           path assoluto del file di log per l'elaborazione
#    logStartingTime:              istante di inizio del logging
#
# Valore restituito
#
#    SUCCESS (0): se il controllo termina con successo
#    FAILURE (1): altrimenti
#################################################################################################

function checkForDataQuality () 
  {
  # Inizializza le variabili mnemoniche per i parametri
  listOfScwsAbsolutePath=$1
  workingDirectoryAbsolutePath=$2
  exeLogAbsolutePath=$3
  logStartingTime=$4
  
  #
  # Debug
  #
  # Verificare il corretto passaggio dei parametri 
  #
  # echo -e "\n######### Debug - Inizio ############################################\n"
  #
  # echo "listOfScwsAbsolutePath: $listOfScwsAbsolutePath"
  # echo "workingDirectoryAbsolutePath: $workingDirectoryAbsolutePath"
  # echo "exeLogAbsolutePath: $exeLogAbsolutePath"
  # echo "logStartingTime: $logStartingTime"
  #
  # echo -e "\n######### Debug - Fine ##############################################\n"
  #
  # exit
  #
  
  # Traccia l'ingresso nella funzione
  appendToLog "$(dateTime)  ${FUNCNAME[0]}() - $MSG_INTO" \
              "$exeLogAbsolutePath"
			  
  #
  # Debug
  #
  #
  # Visualizzare il contenuto del file di log
  #
  # echo -e "\n######### Debug - Inizio ############################################\n"
  #
  # cat $exeLogAbsolutePath
  #
  # echo -e "\n######### Debug - Fine ##############################################\n"
  #
  # exit
  #
			  
  # Forma il nome del file di log per il controllo di qualita' sui dati nel formato
  # $ibisAnalysisEnvSetUp.sh-qualityChekLog-loggingStartingTime 
  qualityCheckLogName="$(basename $0)-$QUALITY_CHECK_LOGS_SUBNAME-$logStartingTime"

  # Forma il path assoluto del file di log per il controllo di qualita' sui dati
  qualityCheckLogAbsolutePath="$workingDirectoryAbsolutePath/$LOGS_DIRECTORY_NAME/$qualityCheckLogName"
			  
  # Inserisce l'intestazione comune ai file di log per il controllo di qualita' sui dati 			
  appendToLog "$(dateTime) ${FUNCNAME[0]} () - $MSG_INTO $DATA_CHECK_LOGS_HEADER \nParameters: \n \
               \t <workingDirectory>: $workingDirectory \n \
               \t <listOfScwsAbsolutePath>: $listOfScwsAbsolutePath \n" \
              "$qualityCheckLogAbsolutePath"

  #
  # Debug
  #
  #
  # Visualizzare il contenuto del file di log
  #
  # echo -e "\n######### Debug - Inizio ############################################\n"
  #
  # cat $qualityCheckLogAbsolutePath
  #
  # echo -e "\n######### Debug - Fine ##############################################\n"
  #
  # exit
  #			  
  
  # Verifica la corrispondenza del contenuto delle scw agli standard fix
  checkForFitsCompliance $listOfScwsAbsolutePath \
                         $exeLogAbsolutePath \
                         $qualityCheckLogAbsolutePath
  
  # salva il risultato della verifica in una variabile di appoggio
  outcome=$?
 
  # Traccia l'uscita dalla funzione
  appendToLog "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF" \
               "$exeLogAbsolutePath"
               
  #
  # Debug
  #
  #
  # Visualizzare il contenuto del file di log
  #
  # echo -e "\n######### Debug - Inizio ############################################\n"
  #
  # cat $exeLogAbsolutePath
  #
  # echo -e "\n######### Debug - Fine ##############################################\n"
  #
  # exit
  #
  
  appendToLog "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF" \
               "$qualityCheckLogAbsolutePath"

  #
  # Debug
  #
  #
  # Visualizzare il contenuto del file di log
  #
  # echo -e "\n######### Debug - Inizio ############################################\n"
  #
  # cat $qualityCheckLogAbsolutePath
  #
  # echo -e "\n######### Debug - Fine ##############################################\n"
  #
  # exit
  #	
			  
  if test $outcome == $SUCCESS
  then
     return $SUCCESS
  else
     return $FAILURE
  fi
  }
  
#################################################################################################
#
# countRunDelimiters()
#
#   Conta il numero di delimitatori di run all'interno del file delle science window  
#
# Parametri
#
#   listOfScwsAbsolutePath: path assoluto del file delle science window
#
# Valore restituito
#   $numberOfRunDelimiters: numero di delimitatori di run all'interno del file delle science window
#
#################################################################################################

function countRunDelimiters () 
  {
  # Inizializza le variabili mnemoniche per i parametri
  listOfScwsAbsolutePath=$1
  
  #
  # Debug
  #
  # Verificare il corretto passaggio dei parametri 
  #
  # echo -e "\n######### Debug - Inizio ############################################\n"
  #
  # echo "listOfScwsAbsolutePath: $listOfScwsAbsolutePath"
  #
  # echo -e "\n######### Debug - Fine ##############################################\n"
  #
  # exit
  #
  
  # Traccia l'ingresso nella funzione
  echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_INTO"
			  
  # Inizializza a 0 il contatore per il numero di delimitatori di run all'interno
  # del file delle science window 
  numberOfRunDelimiters=0
  
  # Scandisce il file riga per riga
  while read line; do
    # Se la riga corrente e' un delimitatore di run aggiorna il contatore
    if test $line == $END_OF_RUN
    then
      # Aggiorna il contatore
      numberOfRunDelimiters=$(expr $numberOfRunDelimiters + 1)
    fi 
  done < $listOfScwsAbsolutePath
  
  # Traccia l'uscita dalla funzione
  echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"

  # restituisce il numero di delimitatori di run individuati
  return $numberOfRunDelimiters
  }

#################################################################################################
#
# checkParallelRunsParameters ()
#
#    Controlla la corretta relazione tra il numero delle run parallele previste per 
#    l'elaborazione, il numero dei delimitatori di run all'interno del file delle science window 
#    da elaborare, il numero di core allocati al container che le elabora e il numero delle scw
#    nel file che le contiene. Piu' in particolare controlla che:
#       - il numero delle run parallele sia maggiore di 0
#       - il numero delle run parallele sia minore o uguale del numero di core assegnati al
#         container
#       - che il numero dei delimitatori di run all'interno del file delle scw da elaborare sia
#         minore o uguale del numero di core assegnati al container
#       - che il numero dei delimitatori di run all'interno del file delle scw da elaborare sia
#         uguale a quello delle run parallele
#       - che il numero delle scw da elaborare sia uguale a quello delle run parallele
#
# Parametri
#
#    numberOfParallelRuns:   numero di run parallele previste per l'elaborazione 
#    numberOfRunDelimiters:  numero di delimitatori di run all'interno del file delle science
#                            window
#    containerNumberOfCores: numero di core assegnati al container utitilizzato per
#                            l'elaborazione
#    scwsToBeProcessed:      numero di scw nel file di quelle da processare
#
# Valore restituito
#    SUCCESS (0):                                      se il controllo ha esito positivo
#    il codice del corrispondente messaggio di errore: altrimenti
#
#################################################################################################

function checkParallelRunsParameters () 
  {
  # Inizializza le variabili mnemoniche per i parametri
  numberOfParallelRuns=$1
  numberOfRunDelimiters=$2
  containerNumberOfCores=$3
  scwsToBeProcessed=$4
  
  #
  # Debug
  #
  # Verificare il corretto passaggio dei parametri
  #
  # echo -e "\n######### Debug - Inizio ############################################\n"
  #
  # echo "numberOfParallelRuns: $numberOfParallelRuns"
  # echo "numberOfRunDelimiters: $numberOfRunDelimiters"
  # echo "containerNumberOfCores: $containerNumberOfCores"
  # echo "scwsToBeProcessed: $scwsToBeProcessed"
  #
  # echo -e "\n######### Debug - Fine ##############################################\n"
  #
  # exit
  #
  
  # Traccia l'ingresso nella funzione
  echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_INTO"
  
  # Se il numero delle run parallele e' minore di 1
  if test $numberOfParallelRuns -le 0
  then
     # Traccia l'uscita dalla funzione	  
     echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"

     # Restituisce il codice del corrispondente messaggio di errore		
     return $ERR_PARALLEL_RUNS_LESS_THAN_1
  fi

  # Se il numero delle run parallele e' maggiore del numero di core assegnati al container
  if test $numberOfParallelRuns -gt $containerNumberOfCores
  then
     # Traccia l'uscita dalla funzione	  
     echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"
	 
     # Restituisce il codice del corrispondente messaggio di errore  
     return $ERR_TOO_MUCH_PARALLEL_RUNS
  fi
  
  # Se il numero dei delimitatori di run all'interno del file delle scw da elaborare e'
  # maggiore del numero di core assegnati al container
  if test $numberOfRunDelimiters -gt $containerNumberOfCores
  then
     # Traccia l'uscita dalla funzione	  
     echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"
 
     # Restituisce il codice del corrispondente messaggio di errore		 
	 return $ERR_TOO_MUCH_RUN_DELIMITERS
  fi
  
  # Se il numero dei delimitatori di run all'interno del file delle scw da elaborare e'
  # maggiore di 0 e diverso da quello delle run parallele
  if test $numberOfRunDelimiters -gt 0
  then
    if test $numberOfParallelRuns -ne $numberOfRunDelimiters
	then
       # Traccia l'uscita dalla funzione	  
       echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"
			
       # Restituisce il codice del corrispondente messaggio di errore			
	   return $ERR_NOT_MATCHING_EOR_PR
	fi
  fi
  
  # Se il numero delle scw da elaborare e' minore di quello delle run parallele
  if test $scwsToBeProcessed -lt $numberOfParallelRuns
  then
     # Traccia l'uscita dalla funzione	  
     echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"
			
     # Restituisce il codice del corrispondente messaggio di errore			
	 return $NOT_ENOUGH_SCWS
  fi
  
  # Traccia l'uscita dalla funzione	  
  echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"
			  
  # Se tutti i controlli hanno esito positivo termina con successo
  return $SUCCESS
  }

#################################################################################################
#
# checkScwsFileSyntax ()
#
#   Controlla che la prima riga (risp. l'ultima) del file delle science window da elaborare non
#   corrisponda (risp. corrisponda) al delimitatore di run, in caso contrario, restituisce il
#   codice del corrispondente messaggio di errore e termina
#
# Parametri
#
#   listOfScwsAbsolutePath: path assoluto del file contenente delle science window
#
# Valore restituito
#    SUCCESS (0):                                      se il controllo ha esito positivo
#    il codice del corrispondente messaggio di errore: altrimenti
#
#################################################################################################

function checkScwsFileSyntax () 
  {
  # Inizializza le variabili mnemoniche per i parametri
  listOfScwsAbsolutePath=$1
  
  #
  # Debug
  #
  # Verificare il corretto passaggio dei parametri 
  #
  # echo -e "\n######### Debug - Inizio ############################################\n"
  #
  # echo "listOfScwsAbsolutePath: $listOfScwsAbsolutePath"
  #
  # echo -e "\n######### Debug - Fine ##############################################\n"
  #
  # exit
  #
  
  # Traccia l'ingresso nella funzione
  echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_INTO"
  
  # Accede alla prima riga del file delle science window da elaborare
  firstLine=$(head -n 1 $listOfScwsAbsolutePath)
  
  # Accede alla prima riga del file delle science window da elaborare
  lastLine=$(tail -n 1 $listOfScwsAbsolutePath)
  
  # Controlla che la prima riga del file delle science window non
  # corrisponda (risp. corrisponda) ad un delimitatore di run, in caso contrario restituisce il
  # codice del corrispondente messaggio di errore e termina
  if test $firstLine == $END_OF_RUN
  then
     # Traccia l'uscita dalla funzione	  
     echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"
			  
     return $ERR_BADLY_FORMED_SCWS_FILE
  fi
  
  # Controlla che la l'ultima riga del file delle science window
  # corrisponda ad un delimitatore di run, in caso contrario restituisce il
  # codice del corrispondente messaggio di errore e termina
  if test $lastLine != $END_OF_RUN
  then
    # Traccia l'uscita dalla funzione	  
    echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"
				
    return $ERR_BADLY_FORMED_SCWS_FILE
  fi
  
  # Traccia l'uscita dalla funzione	  
  echo -e "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF"
			   
  # Se il file delle science window e' ben formato termina con successo	
  return $SUCCESS
  }
  
#################################################################################################
#
# runsDirectoriesContruction()
#
#   Costruisce la struttura a cartelle per le run parallele
#   all'interno della working directory
#
# Parametri
#
#   workingDirectoryAbsolutePath: path assoluto della working directory per la elaborazione
#   numberOfParallelRuns:         numero di run parallele previste per la stessa elaborazione 
#                                 Nel caso in cui il file delle science window non contenga
#                                 delimitatori di run, puo' essere un qualunque valore maggiore
#                                 di 0, altrimenti deve coincidere con il numero di tali
#                                 delimitatori.
#   exeLogAbsolutePath:           path assoluto del file di log per l'elaborazione
#
# Valore restituito
#    SUCCESS (0)
#
#################################################################################################

function runsDirectoriesContruction()
   {
   # Inizializza le variabili mnemoniche per i parametri
   workingDirectoryAbsolutePath=$1
   numberOfParallelRuns=$2
   exeLogAbsolutePath=$3
   
   # Debug
   #
   # Verificare il corretto passaggio dei parametri 
   #
   # echo -e "\n######### Debug - Inizio ############################################\n"
   #
   # echo "workingDirectoryAbsolutePath: $workingDirectoryAbsolutePath"
   # echo "numberOfParallelRuns: $numberOfParallelRuns"
   # echo "exeLogAbsolutePath: $exeLogAbsolutePath"
   #
   # echo -e "\n######### Debug - Fine ##############################################\n"
   #
   # exit
  
   # Traccia l'ingresso nella funzione
   appendToLog "$(dateTime) ${FUNCNAME[0]}() - $MSG_INTO" \
               "$exeLogAbsolutePath"
			   
   #
   # Debug
   #
   #
   # Visualizzare il contenuto del file di log
   #
   # echo -e "\n######### Debug - Inizio ############################################\n"
   #
   # cat $exeLogAbsolutePath
   #
   # echo -e "\n######### Debug - Fine ##############################################\n"
   #
   # exit
   #
   
   # Crea una cartella per ogni run parallela all'interno della working directory
   # assegnandogli come nome quello della stessa working directory seguito da un progressivo
   # da 1 al numero delle run paralllele rappresentato con 3 cifre
   for run in $(seq $numberOfParallelRuns)
   do 
      # Forma il path assoluto della directory assegnata alla run
	  dirAbsolutePath="$workingDirectoryAbsolutePath/$workingDirectory-$(printf "%03d" $run)"
	  
      # Crea la Directory	  
      mkdir $dirAbsolutePath

      # Traccia la creazione della directory
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $RUN_DIR_SUCCESSFULLY_CREATED $dirAbsolutePath" \
                  "$exeLogAbsolutePath"

      #
      # Debug
      #
      #
      # Visualizzare il contenuto del file di log
      #
      # echo -e "\n######### Debug - Inizio ############################################\n"
      #
      # cat $exeLogAbsolutePath
      #
      # echo -e "\n######### Debug - Fine ##############################################\n"
      #
      # exit
      #
   done
   
   # Traccia l'uscita dalla funzione	  
   appendToLog "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF" \
               "$exeLogAbsolutePath"
			   
   #
   # Debug
   #
   #
   # Visualizzare il contenuto del file di log
   #
   # echo -e "\n######### Debug - Inizio ############################################\n"
   #
   # cat $exeLogAbsolutePath
   #
   # echo -e "\n######### Debug - Fine ##############################################\n"
   #
   # exit
   #

   return $SUCCESS   
   }

#################################################################################################
#
# runsSetUp()
#
#   Copia all'interno di ognuna delle cartelle assegnate alle run tutto quanto necessario per
#   la loro esecuzione
#
# Parametri
#
#   listOfScwsAbsolutePath:       path assoluto del file di testo delle scw da elaborare
#   workingDirectoryAbsolutePath: path assoluto della working directory per la elaborazione
#   numberOfParallelRuns:         numero di run parallele previste per l'elaborazione. 
#                                 Nel caso in cui il file delle scw non contenga delimitatori
#                                 di run, puo' essere un qualunque valore maggiore di 0, 
#                                 altrimenti deve coincidere con il numero di tali delimitatori.
#   numberOfRunDelimiters:        numero di delimitatori di run all'interno del file delle scw
#   exeLogAbsolutePath:           path assoluto del file di log per l'elaborazione
#
# Valore restituito
#    SUCCESS (0)
#
#################################################################################################

function runsSetUp()
   {
   # Inizializza le variabili mnemoniche per i parametri
   listOfScwsAbsolutePath=$1
   workingDirectoryAbsolutePath=$2
   numberOfParallelRuns=$3
   numberOfRunDelimiters=$4
   exeLogAbsolutePath=$5
   
   #
   # Debug
   #
   # Verificare il corretto passaggio dei parametri 
   #
   # echo -e "\n######### Debug - Inizio ############################################\n"
   #
   # echo "listOfScwsAbsolutePath: $listOfScwsAbsolutePath"
   # echo "workingDirectoryAbsolutePath: $workingDirectoryAbsolutePath"
   # echo "numberOfParallelRuns: $numberOfParallelRuns"
   # echo "numberOfRunDelimiters: $numberOfRunDelimiters"
   # echo "exeLogAbsolutePath: $exeLogAbsolutePath"
   #
   # echo -e "\n######### Debug - Fine ##############################################\n"
   #
   # exit
   #
   
   # Traccia l'ingresso nella funzione
   appendToLog "$(dateTime) ${FUNCNAME[0]}() - $MSG_INTO" \
               "$exeLogAbsolutePath"
			   
   #
   # Debug
   #
   # Visualizzare il contenuto del file di log relativo all'esecuzione
   #
   # echo -e "\n######### Debug - Inizio ############################################\n"
   #
   # cat $exeLogAbsolutePath
   #
   # echo -e "\n######### Debug - Fine ##############################################\n"
   #
   # exit
   
   # Per ognuna delle run parallele previste per l'elaborazione
   for run in $(seq $numberOfParallelRuns)
   do 	  
      # Forma il path assoluto della directory assegnata alla run
      runDirAbsolutePath="$workingDirectoryAbsolutePath/$workingDirectory-$(printf "%03d" $run)"
	  
      # Forma il path assoluto della directory delle osservazioni
      obsDirAbsolutePath="$runDirAbsolutePath/$OBSERVATIONS_DIRECTORY"

      # Crea all'interno della directory assegnata alla run quella destinata a contenere
      # le osservazioni 	  
      mkdir $obsDirAbsolutePath

      # Traccia la creazione della directory
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $OBS_DIR_SUCCESSFULLY_CREATED $obsDirAbsolutePath" \
                  "$exeLogAbsolutePath"
				  
      # Crea all'interno della directory assegnata alla run il link alla directory ic
      # all'interno dell'archivio dei dati Integral
      ln -s $PATH_OF_IC $runDirAbsolutePath
	  
      # Traccia la creazione del link
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $IC_LINK_SUCCESSFULLY_CREATED $PATH_OF_IC" \
                  "$exeLogAbsolutePath"
	  
      # Crea all'interno della directory assegnata alla run il link alla directory idx
      # all'interno dell'archivio Integral
      ln -s  $PATH_OF_IDX $runDirAbsolutePath
	  
      # Traccia la creazione del link
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $IDX_LINK_SUCCESSFULLY_CREATED $PATH_OF_IDX" \
                  "$exeLogAbsolutePath"
	  
      # Crea all'interno della directory assegnata alla run il link alla directory scw
      # all'interno dell'archivio dei dati Integral
      ln -s  $PATH_OF_SCW $runDirAbsolutePath

      # Traccia la creazione del link
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $SCW_LINK_SUCCESSFULLY_CREATED $PATH_OF_SCW" \
                  "$exeLogAbsolutePath"
				  
      #
      # Debug
      #
      # Visualizzare il contenuto del file di log relativo all'esecuzione
      #
      # echo -e "\n######### Debug - Inizio ############################################\n"
      #
      # cat $exeLogAbsolutePath
      #
      # echo -e "\n######### Debug - Fine ##############################################\n"
      #
      # exit
      #
      
      #
      # Debug
      #
      # Visualizzare il contenuto della directory assegnata alla run
      #
      # echo -e "\n######### Debug - Inizio ############################################\n"
      #
      # ls -a $runDirAbsolutePath
      #
      # echo -e "\n######### Debug - Fine ##############################################\n"
      #
      # exit
      #
   done

   # Distribuisce le scw tra le diverse run
   
   # Inizializza a 0 il contatore delle run processate
   processedRuns=0
   
   # Forma il nome del file delle scw assegnate alla prima run
   runScwFileName="$RUN_SCW_LIST_FILE_PREFIX-$(printf "%03d" $(expr $processedRuns + 1)).txt"

   # Forma il path assoluto della directory assegnata alla prima run
   runDirectoryAbsolutePath="$workingDirectoryAbsolutePath/$workingDirectory-$(printf "%03d" $(expr $processedRuns + 1))"
   
   # Forma il path assoluto del file delle scw assegnate alla prima run
   runScwFileAbsolutePath="$runDirectoryAbsolutePath/$runScwFileName"
   
   # Distribuisce il contenuto del file delle scw tra le diverse run
   if test $numberOfRunDelimiters -eq 0
   then
      # Se il file delle scw non contiene delimitatori di run, le distribuisce in maniera
      # uniforme tra le run stesse
      
      #
      # Debug
      #
      # Evidenziare il caso in cui il file delle scw non contiene EOR
      #
      # echo -e "\n######### Debug - Inizio ############################################\n"
      #
      # echo "Il file delle scw non contiene EOR"
      #
      # echo -e "\n######### Debug - Fine ##############################################\n"
      #
	  
      # Calcola il numero delle scw nel file di quelle da elaborare che le contiene 
      countScwsToBeProcessed $listOfScwsAbsolutePath
      scwsToBeProcessed=$?      
	  
      # Calcola il numero delle "big" run (quando il numero delle scw
      # non e' un multiplo del numero delle run parallele contengono una scw 
      # in piu' rispetto alle "little")
      noOfBigRuns=$(expr $scwsToBeProcessed % $numberOfParallelRuns)
      
      # Calcola il numero delle "little" run (quando il numero delle scw
      # non e' un multiplo del numero delle run parallele contengono una
      # scw in meno rispetto alle "big")
      noOfLittleRuns=$(expr $numberOfParallelRuns - $noOfBigRuns)
      
      # Se il numero delle big run e' 0
      if test $noOfBigRuns -eq 0
      then          
          # Calcola il numero delle scws da assegnare alle "little" run
          noOfBigRuns=$noOfLittleRuns
          bigRunsScws=$(expr $scwsToBeProcessed / $numberOfParallelRuns)
          littleRunsScws=0
          noOfLittleRuns=0
      else    
          # Calcola il numero delle scw da assegnare ad ogni "little" run
          littleRunsScws=$(expr $scwsToBeProcessed / $numberOfParallelRuns)
      
          # Calcola il numero delle scw da assegnare ad ogni "Big" run
          bigRunsScws=$(expr $littleRunsScws + 1)
      fi
      
      #
      # Debug
      #
      # Visualizzare
      #    - il numero delle scw nel file di quelle da elaborare
      #    - il numero delle big run
      #    - il numero delle scw per ogni big run
      #    - il numero delle little run
      #    - il numero delle scw per ogni little run
      #
      #    nel caso in cui il numero delle scw sia un multiplo delle run parallele
      #    nel caso in cui il numero delle scw non sia un multiplo delle run parallele
      #
      # echo -e "\n######### Debug - Inizio ############################################\n"
      #
      # echo "scwsToBeProcessed: $scwsToBeProcessed"
      # echo "noOfBigRuns: $noOfBigRuns"
      # echo "bigRunsScws: $bigRunsScws"
      # echo "noOfLittleRuns: $noOfLittleRuns"
      # echo "littleRunsScws: $littleRunsScws"
      #
      # echo -e "\n######### Debug - Fine ##############################################\n"
      #
      # exit
      #
      
      # Traccia il numero delle scw nel file di quelle da elaborare
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $SCWS_TO_BE_PROCESSED $scwsToBeProcessed" \
                  "$exeLogAbsolutePath"
                  
      # Traccia il numero delle big run
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $NO_OF_BIG_RUNS $noOfBigRuns" \
                  "$exeLogAbsolutePath"
                  
      # Traccia il numero delle scw per big run
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $NO_OF_SCWS_PER_BIG_RUN $bigRunsScws" \
                  "$exeLogAbsolutePath"
                  
      # Traccia il numero delle little run
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $NO_OF_LITTLE_RUNS $noOfLittleRuns" \
                  "$exeLogAbsolutePath"
                  
      # Traccia il numero delle scw per little run
      appendToLog "$(dateTime) ${FUNCNAME[0]}() - $NO_OF_SCWS_PER_LITTLE_RUN $littleRunsScws" \
                  "$exeLogAbsolutePath"
                  
      #
      # Debug
      #
      # Visualizzare il contenuto del file di log relativo all'esecuzione
      #
      # echo -e "\n######### Debug - Inizio ############################################\n"
      #
      # cat $exeLogAbsolutePath
      #
      # echo -e "\n######### Debug - Fine ##############################################\n"
      #
      # exit

      # Inizializza a 0 il numero delle run processate
      processedRuns=0
      
      # Inizializza a 0 il contatore delle scw windows nella run corrente
      scwsInCurrentRun=0
      
      # Inizialitta la variabile relativa al numero di scw previste
      # per la run corrente con quello previsto per le "big" run 
      mandatoryScwsInCurrentRun=$bigRunsScws
      
      # Scandisce il file delle scw riga per riga
      while read line; do
         
         # Appende la linea corrente al file delle scw assegnate alla run
         appendToFile "$line" \
                      "$runScwFileAbsolutePath"

         # Aggiorna il contatore delle scw windows nella run corrente
         scwsInCurrentRun=$(expr $scwsInCurrentRun + 1)
         
         # Se la run corrente contiene il numero previsto di scw
         if test $scwsInCurrentRun -eq $mandatoryScwsInCurrentRun
         then
            #
            # Debug
            #
            # Visualizza il path assoluto del file delle scw associate alla run ed il suo 
            # contenuto
            #           
            # echo -e "\n######### Debug - Inizio ############################################\n"
            #
            # echo "Path assoluto del file delle scw per la run corrente: $runScwFileAbsolutePath"
            # cat $runScwFileAbsolutePath
            #
            # echo -e "\n######### Debug - Fine ##############################################\n"
            
            # Traccia l'avvenuta predisposizione del file delle
            # scw per la run corrente
            appendToLog "$(dateTime) ${FUNCNAME[0]}() - $SCWS_FILE_SUCCESSFULLY_ARRANGED $runScwFileAbsolutePath" \
                        "$exeLogAbsolutePath"
                        
            # Traccia l'avventa predisposizione di quanto necessario all'esecuzione
            # della run corrente
            appendToLog "$(dateTime) ${FUNCNAME[0]}() - $RUN_SUCCESSFULLY_ARRANGED $runDirectoryAbsolutePath" \
                        "$exeLogAbsolutePath"
            
            # Aggiorna il contatore delle run processate
            processedRuns=$(expr $processedRuns + 1)
            
            # Resetta il contatore delle scw nella run corrente
            scwsInCurrentRun=0
            
            # Forma il nome del file delle scw assegnate alla prossima run
            runScwFileName="$RUN_SCW_LIST_FILE_PREFIX-$(printf "%03d" $(expr $processedRuns + 1)).txt"

            # Forma il path assoluto della directory assegnata alla prossima run
            runDirectoryAbsolutePath="$workingDirectoryAbsolutePath/$workingDirectory-$(printf "%03d" $(expr $processedRuns + 1))"
   
            # Forma il path assoluto del file delle scw assegnate alla prossima run
            runScwFileAbsolutePath="$runDirectoryAbsolutePath/$runScwFileName"
            
            # Se la run corrente e' l'ultima "big" run a dover essere processata
            if test $processedRuns -eq $noOfBigRuns
            then
               # Aggiorna la variabile relativa al numero di scw che la
               # run corrente deve contenere con il numero delle scw previste
               # per le little run
               mandatoryScwsInCurrentRun=$littleRunsScws
            fi
         fi             
      done < $listOfScwsAbsolutePath
     
      #
      # Debug
      #
      # Visualizzare il contenuto del file di log relativo all'esecuzione
      #
      # echo -e "\n######### Debug - Inizio ############################################\n"
      #
      # cat $exeLogAbsolutePath
      #
      # echo -e "\n######### Debug - Fine ##############################################\n"
      #
      # exit
   else
      
	  # Altrimenti distribuisce le scw in accordo alla collocazione dei delimitatori di run
	  # all'interno del file che le contiene
      
      #
      # Debug
      #
      # Evidenziare il caso in cui il file delle scw contiene EOR
      #
      # echo -e "\n######### Debug - Inizio ############################################\n"
      #
      # echo "Il file delle scw contiene EOR"
      #
      # echo -e "\n######### Debug - Fine ##############################################\n"
      #
      # exit
      #
	  
	  # Scandisce il file delle scw riga per riga
      while read line; do
         
	     # Se la linea corrisponde ad un delimitatore di run
         if test $line == $END_OF_RUN
	     then
            #
            # Debug
            #
            # Visualizzare il path assoluto del file delle scw associate alla run ed il suo 
            # contenuto
            #           
            # echo -e "\n######### Debug - Inizio ############################################\n"
            #
            # echo "Path assoluto del file delle scw per la run corrente: $runScwFileAbsolutePath"
            # cat $runScwFileAbsolutePath
            #
            # echo -e "\n######### Debug - Fine ##############################################\n"
            #
            # exit
            #
            
            # Traccia l'avvenuta predisposizione del file delle
            # scw per la run corrente
            appendToLog "$(dateTime) ${FUNCNAME[0]}() - $SCWS_FILE_SUCCESSFULLY_ARRANGED $runScwFileAbsolutePath" \
                        "$exeLogAbsolutePath"
                        
            # Traccia l'avventa predisposizione di quanto necessario all'esecuzione
            # della run corrente
            appendToLog "$(dateTime) ${FUNCNAME[0]}() - $RUN_SUCCESSFULLY_ARRANGED $runDirectoryAbsolutePath" \
                        "$exeLogAbsolutePath"
                        
	        # Aggiorna il contatore delle run
	        processedRuns=$(expr $processedRuns + 1)
			
			# Forma il nome del file delle scw assegnate alla prossima run
            runScwFileName="$RUN_SCW_LIST_FILE_PREFIX-$(printf "%03d" $(expr $processedRuns + 1)).txt"
			
            # Forma il path assoluto della directory assegnata alla prossima run
            runDirectoryAbsolutePath="$workingDirectoryAbsolutePath/$workingDirectory-$(printf "%03d" $(expr $processedRuns + 1))"
		 
            # Forma il path assoluto del file delle scw assegnate alla prossima run
            runScwFileAbsolutePath="$runDirectoryAbsolutePath/$runScwFileName"
         else
		    # Appende la linea corrente al file delle scw assegnate alla run
		    appendToFile "$line" \
                         "$runScwFileAbsolutePath"		  
         fi
      done < $listOfScwsAbsolutePath
   fi   

   # Traccia l'uscita dalla funzione	  
   appendToLog "$(dateTime) ${FUNCNAME[0]}() - $MSG_OUT_OF" \
               "$exeLogAbsolutePath"
               
   #
   # Debug
   #
   # Visualizzare il contenuto del file di log relativo all'esecuzione
   #
   # echo -e "\n######### Debug - Inizio ############################################\n"
   #
   # cat $exeLogAbsolutePath
   #
   # echo -e "\n######### Debug - Fine ##############################################\n"
   #
   # exit
			   
   return $SUCCESS   
   }