ftdmp-all-dock

#!/bin/bash

function print_help_and_exit
{
cat >&2 << 'EOF'

'ftdmp-all-dock' docks structures of proteins or nucleic acids

Options:
    --job-name                string  *  job name
    --static-file             string  *  static input file path
    --static-sel              string     query to restrict static atoms, default is '[]'
    --static-chain            string     chain name or chain renaming rule to apply for static atoms, default is ''
    --static-rotation-seed    number     random seed to initially rotate static part, default is 1
    --mobile-file             string  *  mobile input file path
    --mobile-sel              string     query to restrict mobile atoms, default is '[]'
    --mobile-chain            string     chain name or chain renaming rule to apply for mobile atoms, default is ''
    --mobile-rotation-seed    number     random seed to initially rotate mobile part, default is 2
    --symmetry-docking        string     homo docking symmetry to apply for the mobile input file, default is ''
    --openmm-forcefield       string     forcefield name fo OpenMM-based operations, default is ''
    --conda-path              string     conda installation path, default is ''
    --conda-env               string     conda environment name, default is ''
    --sam-parameters          string     additional SAM parameters, default is '-top=8000 -show=2000 -clusters=2000'
    --use-ftdock              string     flag to use ftdock, default is 'true'
    --use-hex                 string     flag to use HEX, default is 'false'
    --ftdock-keep             number     ftdock keep parameter, default is 1
    --ftdock-angle-step       number     ftdock angle step parameter, default is 9
    --ftdock-min-grid-sep     number     ftdock minimum grid separation between same-rotation translations, default is 20
    --hex-macro-mode          string     flag to enable HEX macro mode, default is 'true'
    --hex-max-solutions       number     max number of docking solutions for HEX, default is 10000
    --hex-script              string     semicolon-sparated additional commands for HEX, default is ''
    --hex-swap-and-repeat     string     flag to run HEX twice with monomers swapped, default is 'false'
    --reuse-ftdock-results    string     path to directly input ftdock docking results file and avoid running ftdock, default is ''
    --reuse-hex-results       string     path to directly input hex docking results file and avoid running hex, default is ''
    --parallel                number     number of processes to run when docking with ftdock, default is 8
    --sbatch-for-ftdock       string     sbatch parameters to run docking with ftdock in parallel, default is ''
    --sbatch-for-hex-or-sam   string     sbatch parameters to run docking with HEX or SAM on cluster, default is ''
    --output-dir              string  *  output directory path
    --help | -h                          flag to display help message and exit

Examples:

    ftdmp-all-dock --static-file './chainA.pdb' --mobile-file './chainB.pdb' \
      --output-dir './results' --job-name 'j1'

EOF
exit 1
}

################################################################################

if [ -z "$1" ]
then
	print_help_and_exit
fi

if [ -z "$FTDMPDIR" ]
then
	export FTDMPDIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
	export PATH="${FTDMPDIR}/core/voronota/expansion_js:${FTDMPDIR}/core/3D_Dock/progs:${FTDMPDIR}:${PATH}"
fi

JOB_NAME=""
STATIC_STRUCTURE_FILE=""
STATIC_STRUCTURE_SELECTION="[]"
STATIC_STRUCTURE_CHAIN=""
STATIC_STRUCTURE_ROTATION_SEED="1"
MOBILE_STRUCTURE_FILE=""
MOBILE_STRUCTURE_SELECTION="[]"
MOBILE_STRUCTURE_CHAIN=""
MOBILE_STRUCTURE_ROTATION_SEED="2"
SYMMETRY_DOCKING=""
OPENMM_FORCEFIELD=""
CONDA_PATH=""
CONDA_ENV=""
SAM_PARAMETERS="-top=8000 -show=2000 -clusters=2000"
USE_FTDOCK="true"
USE_HEX="false"
FTDOCK_KEEP="1"
FTDOCK_ANGLE_STEP="9"
FTDOCK_MIN_GRID_SEP="20"
HEX_MACRO_MODE="true"
HEX_MAX_SOLUTIONS="10000"
HEX_SCRIPT=""
HEX_SWAP_AND_REPEAT="false"
REUSE_FTDOCK_DOCKING_RESULTS=""
REUSE_HEX_DOCKING_RESULTS=""
DOCKING_SBATCH_FOR_FTDOCK=""
DOCKING_PROCESSORS="8"
DOCKING_SBATCH_FOR_FTDOCK=""
DOCKING_SBATCH_FOR_HEX_OR_SAM=""
OUTPUT_PATH=""
HELP_MODE="false"

while [[ $# > 0 ]]
do
	OPTION="$1"
	OPTARG="$2"
	shift
	case $OPTION in
	--job-name)
		JOB_NAME="$OPTARG"
		shift
		;;
	--static-file)
		STATIC_STRUCTURE_FILE="$OPTARG"
		shift
		;;
	--static-sel)
		STATIC_STRUCTURE_SELECTION="$OPTARG"
		shift
		;;
	--static-chain)
		STATIC_STRUCTURE_CHAIN="$OPTARG"
		shift
		;;
	--static-rotation-seed)
		STATIC_STRUCTURE_ROTATION_SEED="$OPTARG"
		shift
		;;
	--mobile-file)
		MOBILE_STRUCTURE_FILE="$OPTARG"
		shift
		;;
	--mobile-sel)
		MOBILE_STRUCTURE_SELECTION="$OPTARG"
		shift
		;;
	--mobile-chain)
		MOBILE_STRUCTURE_CHAIN="$OPTARG"
		shift
		;;
	--mobile-rotation-seed)
		MOBILE_STRUCTURE_ROTATION_SEED="$OPTARG"
		shift
		;;
	--symmetry-docking)
		SYMMETRY_DOCKING="$OPTARG"
		shift
		;;
	--openmm-forcefield)
		OPENMM_FORCEFIELD="$OPTARG"
		shift
		;;
	--conda-path)
		CONDA_PATH="$OPTARG"
		shift
		;;
	--conda-env)
		CONDA_ENV="$OPTARG"
		shift
		;;
	--sam-parameters)
		SAM_PARAMETERS="$OPTARG"
		shift
		;;
	--use-ftdock)
		USE_FTDOCK="$OPTARG"
		shift
		;;
	--use-hex)
		USE_HEX="$OPTARG"
		shift
		;;
	--ftdock-keep)
		FTDOCK_KEEP="$OPTARG"
		shift
		;;
	--ftdock-angle-step)
		FTDOCK_ANGLE_STEP="$OPTARG"
		shift
		;;
	--ftdock-min-grid-sep)
		FTDOCK_MIN_GRID_SEP="$OPTARG"
		shift
		;;
	--hex-macro-mode)
		HEX_MACRO_MODE="$OPTARG"
		shift
		;;
	--hex-max-solutions)
		HEX_MAX_SOLUTIONS="$OPTARG"
		shift
		;;
	--hex-script)
		HEX_SCRIPT="$OPTARG"
		shift
		;;
	--hex-swap-and-repeat)
		HEX_SWAP_AND_REPEAT="$OPTARG"
		shift
		;;
	--reuse-ftdock-results)
		REUSE_FTDOCK_DOCKING_RESULTS="$OPTARG"
		shift
		;;
	--reuse-hex-results)
		REUSE_HEX_DOCKING_RESULTS="$OPTARG"
		shift
		;;
	--parallel)
		DOCKING_PROCESSORS="$OPTARG"
		shift
		;;
	--sbatch-for-ftdock)
		DOCKING_SBATCH_FOR_FTDOCK="$OPTARG"
		shift
		;;
	--sbatch-for-hex-or-sam)
		DOCKING_SBATCH_FOR_HEX_OR_SAM="$OPTARG"
		shift
		;;
	--output-dir)
		OUTPUT_PATH="$OPTARG"
		shift
		;;
	-h|--help)
		HELP_MODE="true"
		;;
	*)
		echo >&2 "Error: invalid command line option '$OPTION'"
		exit 1
		;;
	esac
done

if [ "$HELP_MODE" == "true" ]
then
	print_help_and_exit
fi

[ -n "$JOB_NAME" ] || { echo >&2 "Error: job name not provided"; exit 1;}

DOCKING_REGIME=""

if [ -n "$SYMMETRY_DOCKING" ]
then
	[ -z "$STATIC_STRUCTURE_FILE" ] || { echo >&2 "Error: static structure file provided in homo docking mode"; exit 1;}
	
	[ -n "$MOBILE_STRUCTURE_FILE" ] || { echo >&2 "Error: mobile structure file not provided in homo docking mode"; exit 1;}
	[ -s "$MOBILE_STRUCTURE_FILE" ] || { echo >&2 "Error: mobile structure file non-existing or empty in homo docking mode"; exit 1;}
	[ -n "$MOBILE_STRUCTURE_SELECTION" ] || { echo >&2 "Error: mobile structure selection not defined in homo docking mode"; exit 1;}
	
	DOCKING_REGIME="homo"
else
	[ -n "$STATIC_STRUCTURE_FILE" ] || { echo >&2 "Error: static structure file not provided in hetero docking mode"; exit 1;}
	[ -s "$STATIC_STRUCTURE_FILE" ] || { echo >&2 "Error: static structure file non-existing or empty in hetero docking mode"; exit 1;}
	[ -n "$STATIC_STRUCTURE_SELECTION" ] || { echo >&2 "Error: static structure selection not defined in hetero docking mode"; exit 1;}
	
	[ -n "$MOBILE_STRUCTURE_FILE" ] || { echo >&2 "Error: mobile structure file not provided in hetero docking mode"; exit 1;}
	[ -s "$MOBILE_STRUCTURE_FILE" ] || { echo >&2 "Error: mobile structure file non-existing or empty in hetero docking mode"; exit 1;}
	[ -n "$MOBILE_STRUCTURE_SELECTION" ] || { echo >&2 "Error: mobile structure selection not defined in hetero docking mode"; exit 1;}
	
	DOCKING_REGIME="hetero"
fi

if [ "$DOCKING_REGIME" == "hetero" ]
then
	if [ "$USE_FTDOCK" != "true" ] && [ "$USE_HEX" != "true" ]
	then
		echo >&2 "Error: no tool usage turned on for hetero docking"
		exit 1
	fi
	
	if [ -n "$REUSE_FTDOCK_DOCKING_RESULTS" ] && [ ! -s "$REUSE_FTDOCK_DOCKING_RESULTS" ]
	then
		echo >&2 "Error: ftdock results reuse file path provided but invalid"
		exit 1
	fi
	
	if [ -n "$REUSE_HEX_DOCKING_RESULTS" ] && [ ! -s "$REUSE_HEX_DOCKING_RESULTS" ]
	then
		echo >&2 "Error: hex results reuse file path provided but invalid"
		exit 1
	fi
	
	if [ "$USE_FTDOCK" == "true" ] && [ -n "$FTDOCK_ANGLE_STEP" ]
	then
		if [ "$FTDOCK_ANGLE_STEP" -ne "$FTDOCK_ANGLE_STEP" ] || [ "$FTDOCK_ANGLE_STEP" -lt "3" ]
		then
			echo >&2 "Error: invalid ftdock angle step parameter '$FTDOCK_ANGLE_STEP', must be an integer >=3 and a factor of 180"
			exit 1
		fi
	fi
fi

[ -n "$OUTPUT_PATH" ] || { echo >&2 "Error: output path not provided"; exit 1;}

################################################################################

OUTPUT_PATH="${OUTPUT_PATH}/${JOB_NAME}"
mkdir -p "$OUTPUT_PATH"

PREPARED_STATIC_STRUCTURE_FILE=""
PREPARED_MOBILE_STRUCTURE_FILE=""

################################################################################

if [ "$DOCKING_REGIME" == "hetero" ]
then
	PREPARED_STATIC_STRUCTURE_FILE="${OUTPUT_PATH}/monomer_static.pdb"
	
	{
	cat "$STATIC_STRUCTURE_FILE"
	echo "$STATIC_STRUCTURE_SELECTION"
	echo "$STATIC_STRUCTURE_CHAIN"
	echo "$OPENMM_FORCEFIELD"
	} | ftdmp-check-hash --hash-file "${OUTPUT_PATH}/input_hashes/$(basename "$PREPARED_STATIC_STRUCTURE_FILE")" --dependent-file "$PREPARED_STATIC_STRUCTURE_FILE"
	
	if [ ! -s "$PREPARED_STATIC_STRUCTURE_FILE" ]
	then
		ftdmp-prepare-monomer --input "$STATIC_STRUCTURE_FILE" --output "$PREPARED_STATIC_STRUCTURE_FILE" \
		  --restrict-input "$STATIC_STRUCTURE_SELECTION" --rename-chain "$STATIC_STRUCTURE_CHAIN" \
		  --randomize --random-seed "$STATIC_STRUCTURE_ROTATION_SEED" --forcefield "$OPENMM_FORCEFIELD" --conda-path "$CONDA_PATH" --conda-env "$CONDA_ENV"
	fi
	
	if [ ! -s "$PREPARED_STATIC_STRUCTURE_FILE" ]
	then
		echo >&2 "Error: failed to prepare static monomer structure"
		exit 1
	fi
fi

################################################################################

PREPARED_MOBILE_STRUCTURE_FILE="${OUTPUT_PATH}/monomer_mobile.pdb"

{
cat "$MOBILE_STRUCTURE_FILE"
echo "$MOBILE_STRUCTURE_SELECTION"
echo "$MOBILE_STRUCTURE_CHAIN"
echo "$OPENMM_FORCEFIELD"
} | ftdmp-check-hash --hash-file "${OUTPUT_PATH}/input_hashes/$(basename "$PREPARED_MOBILE_STRUCTURE_FILE")" --dependent-file "$PREPARED_MOBILE_STRUCTURE_FILE"

if [ ! -s "$PREPARED_MOBILE_STRUCTURE_FILE" ]
then
	ftdmp-prepare-monomer --input "$MOBILE_STRUCTURE_FILE" --output "$PREPARED_MOBILE_STRUCTURE_FILE" \
	  --restrict-input "$MOBILE_STRUCTURE_SELECTION" --rename-chain "$MOBILE_STRUCTURE_CHAIN" \
	  --randomize --random-seed "$MOBILE_STRUCTURE_ROTATION_SEED" --forcefield "$OPENMM_FORCEFIELD" --conda-path "$CONDA_PATH" --conda-env "$CONDA_ENV"
fi

if [ ! -s "$PREPARED_MOBILE_STRUCTURE_FILE" ]
then
	echo >&2 "Error: failed to prepare mobile monomer structure"
	exit 1
fi

################################################################################

DOCKING_RESULTS_FILE="${OUTPUT_PATH}/docking_results.txt"

if [ "$DOCKING_REGIME" == "hetero" ]
then
	DOCKING_FTDOCK_RESULTS_FILE="${OUTPUT_PATH}/docking_ftdock_results.txt"
	DOCKING_HEX_RESULTS_FILE="${OUTPUT_PATH}/docking_hex_results.txt"
	
	if [ "$USE_FTDOCK" == "true" ]
	then
		{
		cat "$PREPARED_STATIC_STRUCTURE_FILE"
		cat "$PREPARED_MOBILE_STRUCTURE_FILE"
		echo "$FTDOCK_KEEP"
		echo "$FTDOCK_ANGLE_STEP"
		echo "$FTDOCK_MIN_GRID_SEP"
		} | ftdmp-check-hash --hash-file "${OUTPUT_PATH}/input_hashes/$(basename "$DOCKING_FTDOCK_RESULTS_FILE")" --dependent-file "$DOCKING_FTDOCK_RESULTS_FILE"
		
		if [ ! -s "$DOCKING_FTDOCK_RESULTS_FILE" ]
		then
			if [ -z "$REUSE_FTDOCK_DOCKING_RESULTS" ]
			then
				ftdmp-dock-two-monomers-with-ftdock --monomer1 "$PREPARED_STATIC_STRUCTURE_FILE" --monomer2 "$PREPARED_MOBILE_STRUCTURE_FILE" \
				  --job-name "${JOB_NAME}_" \
				  --parallel "$DOCKING_PROCESSORS" --sbatch-parameters "$DOCKING_SBATCH_FOR_FTDOCK" \
				  --ftdock-keep "$FTDOCK_KEEP" \
				  --ftdock-angle-step "$FTDOCK_ANGLE_STEP" \
				  --ftdock-min-grid-sep "$FTDOCK_MIN_GRID_SEP" \
				> "$DOCKING_FTDOCK_RESULTS_FILE"
			else
				cat "$REUSE_FTDOCK_DOCKING_RESULTS" > "$DOCKING_FTDOCK_RESULTS_FILE"
			fi
		fi
	fi
	
	if [ "$USE_HEX" == "true" ]
	then
		{
		cat "$PREPARED_STATIC_STRUCTURE_FILE"
		cat "$PREPARED_MOBILE_STRUCTURE_FILE"
		echo "$HEX_MACRO_MODE"
		echo "$HEX_MAX_SOLUTIONS"
		echo "$HEX_SCRIPT"
		echo "$HEX_SWAP_AND_REPEAT"
		} | ftdmp-check-hash --hash-file "${OUTPUT_PATH}/input_hashes/$(basename "$DOCKING_HEX_RESULTS_FILE")" --dependent-file "$DOCKING_HEX_RESULTS_FILE"
		
		if [ ! -f "$DOCKING_HEX_RESULTS_FILE" ]
		then
			if [ -z "$REUSE_HEX_DOCKING_RESULTS" ]
			then
				ftdmp-dock-two-monomers-with-hex --monomer1 "$PREPARED_STATIC_STRUCTURE_FILE" --monomer2 "$PREPARED_MOBILE_STRUCTURE_FILE" \
				  --job-name "${JOB_NAME}_" \
				  --sbatch-parameters "$DOCKING_SBATCH_FOR_HEX_OR_SAM" \
				  --hex-macro-mode "$HEX_MACRO_MODE" \
				  --hex-max-solutions "$HEX_MAX_SOLUTIONS" \
				  --hex-script "$HEX_SCRIPT" \
				  --hex-swap-and-repeat "$HEX_SWAP_AND_REPEAT" \
				> "$DOCKING_HEX_RESULTS_FILE"
			else
				cat "$REUSE_HEX_DOCKING_RESULTS" > "$DOCKING_HEX_RESULTS_FILE"
			fi
		fi
	fi
	
	{
		if [ "$USE_FTDOCK" == "true" ]
		then
			cat "$DOCKING_FTDOCK_RESULTS_FILE"
		fi
		
		if [ "$USE_HEX" == "true" ] && [ -s "$DOCKING_HEX_RESULTS_FILE" ]
		then
			if [ "$USE_FTDOCK" == "true" ]
			then
				cat "$DOCKING_HEX_RESULTS_FILE" | tail -n +2
			else
				cat "$DOCKING_HEX_RESULTS_FILE"
			fi
		fi
	} > "$DOCKING_RESULTS_FILE"
fi

if [ "$DOCKING_REGIME" == "homo" ]
then
	{
	cat "$PREPARED_MOBILE_STRUCTURE_FILE"
	echo "$SYMMETRY_DOCKING"
	echo "$SAM_PARAMETERS" | sed 's/\s\+/ /g'
	} | ftdmp-check-hash --hash-file "${OUTPUT_PATH}/input_hashes/$(basename "$DOCKING_RESULTS_FILE")" --dependent-file "$DOCKING_RESULTS_FILE"
	
	if [ ! -s "$DOCKING_RESULTS_FILE" ]
	then
		ftdmp-dock-symmetric --monomer "$PREPARED_MOBILE_STRUCTURE_FILE" \
		  --job-name "${JOB_NAME}" \
		  --sbatch-parameters "$DOCKING_SBATCH_FOR_HEX_OR_SAM" \
		  --symmetry "$SYMMETRY_DOCKING" \
		  --sam-parameters "$SAM_PARAMETERS" \
		  --output-dir "${OUTPUT_PATH}/homo_complexes" \
		> "$DOCKING_RESULTS_FILE"
	fi
fi

PREV_SCORING_RESULTS_FILE="$DOCKING_RESULTS_FILE"

################################################################################