run

#! /bin/bash
#
# Run script for flywheel/hcp-icafix Gear.
#
# Authorship: Keith Jamison
#

##############################################################################
# Define directory names and containers

FLYWHEEL_BASE=/flywheel/v0
INPUT_DIR=$FLYWHEEL_BASE/input
OUTPUT_DIR=$FLYWHEEL_BASE/output
SCRIPT_DIR=${FLYWHEEL_BASE}/scripts
SCENE_DIR=${FLYWHEEL_BASE}/scenes
CONFIG_FILE=$FLYWHEEL_BASE/config.json
CONTAINER='[flywheel/hcp-icafix]'

source ${FLYWHEEL_BASE}/docker-env.sh

source ${SCRIPT_DIR}/bash_functions.sh # some useful tools

##############################################################################
# Parse configuration

# If the config file does not exist (i.e., local run) then parse the config
# options and values from the manifest. Those variables can be found in the
# manifest.json file within the `config` map.

if [[ -f $CONFIG_FILE ]]; then
  eval $(jq -r '.inputs | to_entries[] | "FW_INPUT_\(.key)=\(.value.location.path)"' $CONFIG_FILE)
  echo "$(set | grep FW_INPUT)"
fi

function parse_config {
  CONFIG_FILE=$FLYWHEEL_BASE/config.json
  MANIFEST_FILE=$FLYWHEEL_BASE/manifest.json

  if [[ -f $CONFIG_FILE ]]; then
    echo -e "$(cat $CONFIG_FILE | jq -r '.config.'$1)"
  else
    CONFIG_FILE=$MANIFEST_FILE
    echo -e "$(cat $MANIFEST_FILE | jq -r '.config.'$1'.default')"
  fi
}

FW_CONFIG_Subject="$(parse_config 'Subject')"
FW_CONFIG_FIXClassifier="$(parse_config 'FIXClassifier')"
FW_CONFIG_RegName="$(parse_config 'RegName')"
FW_CONFIG_HighPassFilter="$(parse_config 'HighPassFilter')"
FW_CONFIG_PreserveOnError="$(parse_config 'PreserveOnError')"

if [[ "$FW_CONFIG_PreserveOnError" == 'false' ]]; then
  FW_CONFIG_PreserveOnError=''
fi

##############################################################################
# use "echo" for testing arguments without running scripts
RUN_FIX=""
RUN_POSTFIX=""
RUN_RSS=""
RUN_QC=""

##############################################################################
# Set some pipeline defaults

source ${SCRIPT_DIR}/SetUpHCPPipeline.sh

StudyFolder=${OUTPUT_DIR}

PRINTCOM=""
QUEUE=""

LogFileDir=logs
LogFileDirFull=${OUTPUT_DIR}/${LogFileDir}
mkdir -p ${LogFileDirFull}
FSLSUBOPTIONS="-l ${LogFileDirFull} -v"

#######################################
# Process inputs and config options from app


if [[ -z "${FW_INPUT_StructZip}" ]]; then
  echo -e "${CONTAINER} [$(timestamp)] INPUT_DIR has no valid StructZip files!"
  exit 1
else
  StructZipFile="${FW_INPUT_StructZip}"
fi

if [[ -z "${FW_INPUT_FuncZip}" ]]; then
  echo -e "${CONTAINER} [$(timestamp)] INPUT_DIR has no valid FuncZip files!"
  exit 1
else
  FuncZipFile="${FW_INPUT_FuncZip}"
fi

# Extract some info from .json saved in hcpfunc zip file
FuncConfigFile="hcpfunc_config.json"
unzip -p ${FuncZipFile} '*hcpfunc_config.json' > ${FuncConfigFile}
hcpfunc_Subject=$(jq -r '.config.Subject // empty' ${FuncConfigFile})
hcpfunc_RegName=$(jq -r '.config.RegName // empty' ${FuncConfigFile})
hcpfunc_FinalfMRIResolution=$(jq -r '.config.FinalfMRIResolution // empty' ${FuncConfigFile})
hcpfunc_GrayordinatesResolution=$(jq -r '.config.GrayordinatesResolution // empty' ${FuncConfigFile})
hcpfunc_LowResMesh=$(jq -r '.config.LowResMesh // empty' ${FuncConfigFile})
hcpfunc_SmoothingFWHM=$(jq -r '.config.SmoothingFWHM // empty' ${FuncConfigFile})

if [[ -z "${hcpfunc_Subject}" ]]; then
  echo -e "${CONTAINER} [$(timestamp)] ${FuncZipFile} did not contain ${FuncConfigFile}!"
  echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory and exiting!"
  cleanup ${FW_CONFIG_PreserveOnError}
  exit 1
fi

# Select RData file from based on INPUT or CONFIG
unset ClassifierFile
if [[ -e "${FW_INPUT_CustomClassifier}" ]]; then
  # If user provides RData file, use that
  ClassifierFile="${FW_INPUT_CustomClassifier}"
elif [[ ! -z "${FW_CONFIG_FIXClassifier}" ]]; then
  tmpfix=$(basename $(toupper "${FW_CONFIG_FIXClassifier}") .RDATA)
  for f in ${FSL_FIXDIR}/training_files/*.RData; do
    f1=$(toupper $(basename $f .RData))
    if [[ "$f1" = "$tmpfix" ]]; then
      ClassifierFile=$f
      break
    fi
  done
  if [[ ! -e "${ClassifierFile}" ]]; then
    echo -e "${CONTAINER} [$(timestamp)] No RData training file found: ${FW_CONFIG_FIXClassifier}!"
    echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory and exiting!"
    cleanup ${FW_CONFIG_PreserveOnError}
    exit 1
  fi
fi


if [[ -z "${FW_CONFIG_Subject}" ]] || [[ $(toupper "${FW_CONFIG_Subject}") = "EMPTY" ]] || [[ $(toupper "${FW_CONFIG_Subject}") = "NULL" ]]; then
  Subject="${hcpfunc_Subject}"
else
  Subject="${FW_CONFIG_Subject}"
fi

if [[ -z "${FW_CONFIG_RegName}" ]] || [[ $(toupper "${FW_CONFIG_RegName}") = "EMPTY" ]] || [[ $(toupper "${FW_CONFIG_RegName}") = "NULL" ]]; then
  RegName="${hcpfunc_RegName}"
else
  RegName="${FW_CONFIG_RegName}"
fi

# Must match the HPF of the training dataset (generally 2000sec)
HighPassFilterSeconds="2000"
if [[ ! -z "${FW_CONFIG_HighPassFilter}" ]]; then
  HighPassFilterSeconds="${FW_CONFIG_HighPassFilter}"
fi


# Copy some of the saved hcpfunc config params if present
LowResMesh="32"
FinalfMRIResolution="2"
BrainOrdinatesResolution="2"
SmoothingFWHM="${FinalfMRIResolution}"

if [[ ! -z "${hcpfunc_FinalfMRIResolution}" ]]; then
  FinalfMRIResolution=${hcpfunc_FinalfMRIResolution}
fi

if [[ ! -z "${hcpfunc_GrayordinatesResolution}" ]]; then
  BrainOrdinatesResolution=${hcpfunc_GrayordinatesResolution}
fi

if [[ ! -z "${hcpfunc_LowResMesh}" ]]; then
  LowResMesh=${hcpfunc_LowResMesh}
fi

if [[ ! -z "${hcpfunc_SmoothingFWHM}" ]]; then
  SmoothingFWHM=${hcpfunc_SmoothingFWHM}
fi

################################################################################
# Unzip HCP-Structural and HCP-Functional outputs

echo -e "${CONTAINER} [$(timestamp)] Unzipping HCP-Structural zip: " $(basename ${StructZipFile})
unzip -o -q ${StructZipFile} -d ${StudyFolder}

# Identify available HCP-Functional inputs
# 1. extract fMRIName from hcpfunc_config.json
# 2. make sure it doesn't conflict with other inputs
# 3. unzip contents
FuncZipList=""
fMRINameList=""
for i in 1 2 3 4 5 6 7 8 9 10; do
  if [[ $i == 1 ]]; then
    FuncZip="$FuncZipFile"
  else
    tmpv="FW_INPUT_FuncZip$i"; tmpv=${!tmpv}
    if [[ ! -e "${tmpv}" ]]; then
      continue
    fi
    FuncZip="${tmpv}"
  fi

  FuncZipList+=" ${FuncZip}"

  echo -e "${CONTAINER} [$(timestamp)] Unzipping HCP-Functional input #${i}:" $(basename ${FuncZip})

  tmp_FuncConfigFile=`mktemp -d`"/hcpfunc_config.json"
  unzip -p ${FuncZip} '*hcpfunc_config.json' > ${tmp_FuncConfigFile}
  tmp_fMRIName=$(jq -r '.config.fMRIName // empty' ${tmp_FuncConfigFile})
  rm -f ${tmp_FuncConfigFile}

  #check for fMRIName conflicts (eg: entered the same FuncZip twice)
  if [ -z "${tmp_fMRIName}" ]; then
    echo -e "${CONTAINER} [$(timestamp)] $(basename ${FuncZip}) did not contain config.json!"
    echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory and exiting!"
    cleanup ${FW_CONFIG_PreserveOnError}
    exit 1
  elif [[ $(countunique ${fMRINameList} ${tmp_fMRIName}) == $(countunique ${fMRINameList}) ]]; then
    echo -e "${CONTAINER} [$(timestamp)] $(basename ${FuncZip}) fMRIName conflicts with another FuncZip entry!"
    echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory and exiting!"
    cleanup ${FW_CONFIG_PreserveOnError}
    exit 1
  fi
  fMRINameList+=" ${tmp_fMRIName}"

  #only need to unzip MNINonLinear/Results for ICAFIX
  unzip -o -q ${FuncZip} "${Subject}/MNINonLinear/Results/*" -d ${StudyFolder}
done

#Create @-separated list of preprocessed nifti for each input
fMRINameList_new=
fMRIFileList=
fMRIFileCount=0
for f in ${fMRINameList}; do
  fMRIFile=${StudyFolder}/${Subject}/MNINonLinear/Results/${f}/${f}.nii.gz
  if [ -e "$fMRIFile" ]; then
    fMRINameList_new+="${f} "
    fMRIFileList+="${fMRIFile}@"
    fMRIFileCount=$((fMRIFileCount+1))
  else
    echo -e "${CONTAINER} [$(timestamp)] Preprocessed fMRI time-series not found: $f"
  fi
done
fMRINameList="${fMRINameList_new}"

if [[ "$fMRIFileCount" == "0" ]]; then
  echo -e "${CONTAINER} [$(timestamp)] No valid HCP-Functional zips!"
  echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory and exiting!"
  cleanup ${FW_CONFIG_PreserveOnError}
  exit 1
elif [[ "$fMRIFileCount" == "1" ]]; then
  fMRINameList=$(echo $fMRINameList) #trim whitespace
  fMRIFileList=${fMRIFileList/@/""} #trim "@"
fi

# save list of files extracted from hcpstruct zip so we can remove them from output
# (specifically, list of ALL files that exist in OUTPUT_DIR at this point)
OrigFiles=${OUTPUT_DIR}/filecache_orig.txt
FinalFiles=${OUTPUT_DIR}/filecache_final.txt
FilesToRemove=${OUTPUT_DIR}/filecache_delete.txt
${SCRIPT_DIR}/file_cache.sh -list ${StudyFolder}/${Subject} > ${OrigFiles}

################################################################################
# Run ICAFIX

if [[ "$fMRIFileCount" == "1" ]]; then
  echo -e "${CONTAINER} [$(timestamp)] Starting: Single-Run ICA-FIX Pipeline"

  # patched version is copied into here
  FixScript=${HCPPIPEDIR}/ICAFIX/hcp_fix

  pipeline_status_code=0
  set -x
  ${RUN_FIX} ${FSLDIR}/bin/fsl_sub ${QUEUE} ${FSLSUBOPTIONS} \
    ${FixScript} \
      ${fMRIFileList} \
      ${HighPassFilterSeconds} \
      ${ClassifierFile}
  set +x
  pipeline_status_code=$?
  echo -e "${CONTAINER} [$(timestamp)] Exit code was: $pipeline_status_code"


  PostFixName=${fMRINameList}
  PostFixHP="NO"
  RSSBC="REVERT"

else
  echo -e "${CONTAINER} [$(timestamp)] Starting: Multi-Run ICA-FIX Pipeline"

  FixScript=${HCPPIPEDIR}/ICAFIX/hcp_fix_multi_run

  ConcatName="ICAFIX_multi"
  for f in ${fMRINameList}; do
    ConcatName+="_${f}"
  done
  ConcatFile="${StudyFolder}/${Subject}/MNINonLinear/Results/${ConcatName}/${ConcatName}.nii.gz"

  pipeline_status_code=0
  set -x
  ${RUN_FIX} ${FSLDIR}/bin/fsl_sub ${QUEUE} ${FSLSUBOPTIONS} \
    ${FixScript} \
      ${fMRIFileList} \
      ${HighPassFilterSeconds} \
      ${ConcatFile} \
      ${ClassifierFile}
  set +x
  pipeline_status_code=$?
  echo -e "${CONTAINER} [$(timestamp)] Exit code was: $pipeline_status_code"


  PostFixName=${ConcatName}
  PostFixHP="YES"
  RSSBC="NONE"

fi

FIXnoisefile=$( ls ${StudyFolder}/${Subject}/MNINonLinear/Results/${PostFixName}/${PostFixName}*.ica/.fix 2>/dev/null )
FIXmixfile=$( ls ${StudyFolder}/${Subject}/MNINonLinear/Results/${PostFixName}/${PostFixName}*.ica/filtered_func_data.ica/melodic_mix 2>/dev/null )

if [ -e "${FIXnoisefile}" ]; then
  #Print summary of classification results
  numICA=$(cat $FIXmixfile | head -n1 | wc -w)
  numNoise=$(cat $FIXnoisefile | wc -w)
  numSignal=$((numICA - numNoise))

  echo -e "${CONTAINER} [$(timestamp)] ICA-FIX classified ${numNoise}/${numICA} ICA components as noise"
else
  #FIX results were not created!
  echo -e "${CONTAINER} [$(timestamp)] FIX results were not created!"
  pipeline_status_code=1
fi

# NOTE: Currently these exit codes do NOT reflect success or failure!
if [[ $pipeline_status_code == 0 ]]; then
  echo -e "${CONTAINER} [$(timestamp)] ICA-FIX Success!"
else
  echo -e "${CONTAINER} [$(timestamp)] ICA-FIX Failure!"
  echo -e "${CONTAINER} [$(timestamp)] Exit code was: $pipeline_status_code"
  echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory and exiting!"
  cleanup ${FW_CONFIG_PreserveOnError}
  ${RUN_FIX} exit 1
fi

################################################################################
# Run PostFix (generate classification scene files)
echo -e "${CONTAINER} [$(timestamp)] Starting: PostFix Pipeline"

#PostFix creates scene files, ReclassifyAsNoise.txt, ReclassifyAsSignal.txt, ${fMRIName}.ica/Noise.txt, ${fMRIName}.ica/Signal.txt
# and some cifti outputs in ${fMRIName}.ica/filtered_func.ica/

PostFixMatlabMode="0" #Compiled matlab
DualScene=${HCPPIPEDIR}/PostFix/PostFixScenes/ICA_Classification_DualScreenTemplate.scene
SingleScene=${HCPPIPEDIR}/PostFix/PostFixScenes/ICA_Classification_SingleScreenTemplate.scene

pipeline_status_code=0
set -x
${RUN_POSTFIX} ${FSLDIR}/bin/fsl_sub ${QUEUE} ${FSLSUBOPTIONS} \
  ${HCPPIPEDIR}/PostFix/PostFix.sh \
    --study-folder=${StudyFolder} \
    --subject=${Subject} \
    --fmri-name=${PostFixName} \
    --high-pass=${HighPassFilterSeconds} \
    --template-scene-dual-screen=${DualScene} \
    --template-scene-single-screen=${SingleScene} \
    --reuse-high-pass=${PostFixHP} \
    --matlab-run-mode=${PostFixMatlabMode}
set +x
pipeline_status_code=$?
echo -e "${CONTAINER} [$(timestamp)] Exit code was: $pipeline_status_code"

if [ -e ${StudyFolder}/${Subject}_${PostFixName}.matlab.log ]; then
  ${RUN_POSTFIX} mv ${StudyFolder}/${Subject}_${PostFixName}.matlab.log ${LogFileDirFull}/PostFix.matlab.log
fi

postfix_scenefile="${StudyFolder}/${Subject}/MNINonLinear/Results/${PostFixName}/${Subject}_${PostFixName}_ICA_Classification_singlescreen.scene"
if [ -e "${postfix_scenefile}" ]; then
  SceneZipFileName=${Subject}_${PostFixName}_ICA_Classification_Scene
  echo -e "${CONTAINER} [$(timestamp)] Creating PostFix wb_view scene zip: ${SceneZipFileName}.zip"

  ${RUN_POSTFIX} ${SCRIPT_DIR}/create_postfix_scene_zip.sh \
    ${OUTPUT_DIR} \
    ${Subject} \
    ${PostFixName} \
    ${SceneZipFileName} > ${LogFileDirFull}/PostFix_scene_zip.log

  ${RUN_POSTFIX} unzip -l ${SceneZipFileName}.zip > ${SceneZipFileName}.zip.log
else
  #PostFix output file does not exist!
  echo -e "${CONTAINER} [$(timestamp)] PostFix output file does not exist!"
  pipeline_status_code=1
fi

# NOTE: Currently these exit codes do NOT reflect success or failure!
if [[ $pipeline_status_code == 0 ]]; then
  echo -e "${CONTAINER} [$(timestamp)] PostFix Success!"
else
  echo -e "${CONTAINER} [$(timestamp)] PostFix Failure!"
  echo -e "${CONTAINER} [$(timestamp)] Exit code was: $pipeline_status_code"
  echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory and exiting!"
  cleanup ${FW_CONFIG_PreserveOnError}
  ${RUN_POSTFIX} exit 1
fi

################################################################################
# Run RestingStateStats (quality metrics after FIX classification and denoising)
echo -e "${CONTAINER} [$(timestamp)] Starting: RestingStateStats Pipeline"

OutputProcSTRING="_hp${HighPassFilterSeconds}_clean"
OutSTRING="stats"

dlabelFile="NONE"
BCMode=$RSSBC #REVERT for single-run, NONE for multi-run (7T used "NONE")
WM="${HCPPIPEDIR}/global/config/FreeSurferWMRegLut.txt"
CSF="${HCPPIPEDIR}/global/config/FreeSurferCSFRegLut.txt"

RSSMatlabMode="0" #Compiled matlab

pipeline_status_code=0
set -x
${RUN_RSS} ${FSLDIR}/bin/fsl_sub ${QUEUE} ${FSLSUBOPTIONS} \
  ${HCPPIPEDIR}/RestingStateStats/RestingStateStats.sh \
    --path=${StudyFolder} \
    --subject=${Subject} \
    --fmri-name=${PostFixName} \
    --high-pass=${HighPassFilterSeconds} \
    --reg-name=${RegName} \
    --low-res-mesh=${LowResMesh} \
    --final-fmri-res=${FinalfMRIResolution} \
    --brain-ordinates-res=${BrainOrdinatesResolution} \
    --smoothing-fwhm=${SmoothingFWHM} \
    --output-proc-string=${OutputProcSTRING} \
    --dlabel-file=${dlabelFile} \
    --matlab-run-mode=${RSSMatlabMode} \
    --bc-mode=${BCMode} \
    --out-string=${OutSTRING} \
    --wm=${WM} \
    --csf=${CSF}
set +x
pipeline_status_code=$?
echo -e "${CONTAINER} [$(timestamp)] Exit code was: $pipeline_status_code"

if [ -e ${StudyFolder}/${Subject}_${PostFixName}.matlab.log ]; then
  ${RUN_RSS} mv ${StudyFolder}/${Subject}_${PostFixName}.matlab.log ${LogFileDirFull}/RestingStateStats.matlab.log
fi

rss_statsfile=$( ls ${StudyFolder}/${Subject}/MNINonLinear/Results/${PostFixName}/${PostFixName}_*_stats.dscalar.nii 2>/dev/null )
if [ -e "${rss_statsfile}" ]; then
  #Copy RestingStateStats output PNG to output root dir
  echo -e "${CONTAINER} [$(timestamp)] Copying RestingStateStats images to output"
  ${RUN_RSS} cp -f ${StudyFolder}/${Subject}/MNINonLinear/Results/${PostFixName}/RestingStateStats/*_OrigTCS_QC_Summary_Plot.png ${StudyFolder}/
  ${RUN_RSS} cp -f ${StudyFolder}/${Subject}/MNINonLinear/Results/${PostFixName}/RestingStateStats/*_CleanedTCS_QC_Summary_Plot.png ${StudyFolder}/

  rss_zipfile=${Subject}_${PostFixName}_RestingStateStats.zip
  echo -e "${CONTAINER} [$(timestamp)] Zipping RestingStateStats results: ${rss_zipfile}"

  #Current approach: Create separate RSS zip for easier access, which will unzip directly into:
  # <current directory>/${fMRIName}_Atlas_stats.dscalar.nii
  # <current directory>/${fMRIName}_Atlas_stats.txt
  # <current directory>/RestingStateStats/*.png
  (
    cd ${StudyFolder}/${Subject}/MNINonLinear/Results/${PostFixName};
    ${RUN_RSS} rm -f ${OUTPUT_DIR}/${rss_zipfile};
    ${RUN_RSS} zip -r ${OUTPUT_DIR}/${rss_zipfile} \
      *_stats.dscalar.nii \
      *_stats.txt \
      RestingStateStats/ \
      > ${LogFileDirFull}/${rss_zipfile}.log
  )
else
  #RSS output file does not exist!
  echo -e "${CONTAINER} [$(timestamp)] RSS output file does not exist!"
  pipeline_status_code=1
fi

# NOTE: Currently these exit codes do NOT reflect success or failure!
if [[ $pipeline_status_code == 0 ]]; then
  echo -e "${CONTAINER} [$(timestamp)] RestingStateStats Success!"
else
  echo -e "${CONTAINER} [$(timestamp)] RestingStateStats Failure!"
  echo -e "${CONTAINER} [$(timestamp)] Exit code was: $pipeline_status_code"
  echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory and exiting!"
  cleanup ${FW_CONFIG_PreserveOnError}
  ${RUN_RSS} exit 1
fi

################################################################################
# Generate ICAFIX QC Images
# TODO: maybe some volume mosaics with mean and stdev like at the end of hcp-func?
# TODO: maybe some scene renderings from RSS?

################################################################################
# Clean-up and prepare outputs

# Delete files that came from the HCP-Structural and HCP-Functional zip input
${SCRIPT_DIR}/file_cache.sh -list ${StudyFolder}/${Subject} > ${FinalFiles}
${SCRIPT_DIR}/file_cache.sh -diff ${OrigFiles} ${FinalFiles} > ${FilesToRemove}

cd ${StudyFolder}
for f in $(cat ${FilesToRemove}); do
  rm -f $f
done
rm -f ${FilesToRemove} ${OrigFiles} ${FinalFiles}

# Add current gear config.json to output for reference in subsequent gears
# - For now, don't copy full input json since it might contain identifiers from DICOM etc
# - add/update .config.RegName since it might not have been included in config (pre-MSM availability)
# - add/update .config.Subject since it might later be pulled from other session metadata
# - add/update .config.fMRINameList so we have a record of which scans went into this
# TODO: fMRINameList should be stored somewhere more appropriate!
# - This jq call does the value replacement, then selects just .config but stores it back into a
#    new element called ".config" so the new file can be read as though it was flywheel config.json
OUTPUT_CONFIG_FILE=${StudyFolder}/${Subject}/${Subject}_${fMRIName}_hcpicafix_config.json
jq -r '.config.RegName = "'$RegName'" | .config.Subject = "'$Subject'" | .config | {config: .}' $CONFIG_FILE \
  | jq -r '.config.fMRINameList = "'"${fMRINameList}"'"' > ${OUTPUT_CONFIG_FILE}

# If pipeline successful, zip outputs and clean up
outputzipname=${Subject}_${PostFixName}_hcpicafix.zip
echo -e "${CONTAINER} [$(timestamp)] Zipping output file ${outputzipname}"
ziplistfile=${OUTPUT_DIR}/${outputzipname}.list.txt
rm -f ${ziplistfile}
rm -f ${OUTPUT_DIR}/${outputzipname}
cd ${StudyFolder}
# include all remaining files in functional output zip
find ${Subject} -type f > ${ziplistfile}
cat ${ziplistfile} | zip ${OUTPUT_DIR}/${outputzipname} -@ > ${OUTPUT_DIR}/${outputzipname}.log
rm -f ${ziplistfile}

# zip pipeline logs
logzipname=pipeline_logs.zip
echo -e "${CONTAINER} [$(timestamp)] Zipping pipeline logs to ${logzipname}"
cd ${OUTPUT_DIR}
zip -r ${OUTPUT_DIR}/${logzipname} ${LogFileDir}/ > ${OUTPUT_DIR}/${logzipname}.log

echo -e "${CONTAINER} [$(timestamp)] Cleaning output directory"
rm -rf ${StudyFolder}/${Subject}/
rm -rf ${LogFileDirFull}/

echo -e "${CONTAINER} [$(timestamp)] Final output directory listing:"
cd ${OUTPUT_DIR}
du -hs *

exit $pipeline_status_code