np3

#!/bin/bash

# ============================================================================= #
# |                    **** USAGE OF NETPROPHET 3.0 ****                      | #
# ============================================================================= #
usage(){
cat << EOF
    netprophet3.0 [options]
    
    INPUT arguments:
    --p_in_expr_target            : input file for expression of target genes (target x sample)
    --p_in_expr_reg               : input file for expression of regulators (reg x sample)
    --p_in_net_de                 : input file for network of differential expression
    --p_in_binding_event          : input file for binding events |REGULATOR|TARGET|
    --seed                        : seed for generating the fold cross valition (default 747)
    
    LASSO arguments:
    --flag_local_shrinkage        : "ON" for estimating a shrinkage parameter for every target gene, "OFF" otherwise (default "ON")
    --flag_global_shrinkage       : "ON" for estimating a shrinkage parameter for all target genes, "OFF" otherwise (default "OFF")
    --flag_microarray             : "MICROARRAY" for microarray expression data, "RNA-SEQ" for RNA-Seq data
    --lasso_nbr_fold              : number of folds used for estimating lambda in lasso (optional, default 10)
        
    BART arguments:
    --bart_ntree                  : number of trees for BART algorithms (default 50)
    
    PWM arguments:
    --p_in_promoter               : path of promoter fasta sequences for building PWM networks 
    
    COMBINE arguments:
    --l_in_name_net               : a string of name of networks: "lasso,de,bart,pwm"
    --l_in_path_net               : a string of path of networks: "${path_lasso},${path_de},${path_bart},${path_pwm}" 
    --flag_penalize               : "ON" or "L1", "L2", or "L1_L2" or "XGBOOST-OPTIMIZE" (optional, default is "OFF")
    --flag_training               : "ON-CV", "ON-SUB", "ON-INT", or "OFF" for 10-CV, training with specific number of TFs, training for integration, or using an already trained model (optional, default is "OFF")
    combine method: default coef  :
    --p_in_model                  : path of pre-built model, goes with flag_training="OFF"
    combine method: small subset  :
    --in_nbr_reg                  : number of regulators (TFs) for training, goes flag_training="ON-SUB"
    combine method: 10cv          :
    --combine_cv_nbr_fold            : number of cross-validation default 10, goes with flag_training="ON-CV"
    
    OUTPUT arguments:
    --p_out_dir                   : path of output directory
    
    LOGISTIC arguments:
    --p_src_code                  : path for source of code (optional)
    
    SINGULARITY arguments:
    --flag_singularity            : "ON" or "OFF", default "ON" for using singularity container 
    --p_singularity_img           : path of singularity container
    --p_singularity_bindpath      : path of directory of output file
    
    SLURM arguments:
    --flag_slurm                  : "ON" for (slurm) run, "OFF" otherwise.
    --p_out_dir_logs              : output file for logs (.out & .err) for slurm runs
    --mail_user                   : mail address of the user for slurm run logs
    --mail_type                   : when to send an email to the user (default FAIL)
    --data                        : prefix of job names for slurm jobs      
    
    -h                            : display usage for netprophet3.0 commandline
    -a                            : run ALL components
    -l                            : run only the LASSO component
    -b                            : run only the BART component
    -m                            : run only the PWM component
    -c                            : run only the COMBINE component
    
EOF
}

# ======================================================================================================= #
# |                                   **** PARSE ARGUMENTS ****                                         | #
# ======================================================================================================= #

# ------------------------------------------------------------------------------------- #
# |         *** Read default arguments: these arguments are not mandatory ***         | #
# ------------------------------------------------------------------------------------- #




# LASSO arguments
flag_local_shrinkage="ON"
flag_global_shrinkage="OFF"
flag_microarray="MICROARRAY"
lasso_nbr_fold=10
lasso_slurm_nodes=1
lasso_slurm_mem=10G

# BART
bart_slurm_nodes=1
bart_slurm_ntasks=15
bart_slurm_mem=20G
bart_ntree=50

# COMBINATION arguments
p_in_binding_event="NONE"
l_in_name_net=""
l_in_path_net=""
in_model_name="atomic"

# COMBINATION 10CVx
combine_cv_nbr_fold=10

# COMBINATION SMALL SUBSET
in_nbr_reg="NONE"

# COMBINATION PRE-BUILT MODEL
flag_training="OFF"
flag_penalize="XGBOOST-OPTIMIZE"
in_coef="NONE"
p_in_model="NONE"

# COMBINATION SLURM
combine_slurm_mem=20G
combine_slurm_nodes=3
combine_slurm_ntasks_per_node=2
combine_slurm_cpus_per_task=2
combine_slurm_ntasks=5

# COMBINATION WITH REGRESSION
flag_intercept="ON"
penalize_nbr_fold=10

# LOGISTICS
p_src_code="$(cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd)/"
p_progress="NONE"
flag_debug="OFF"
seed=747

# SLURM arguments
mail_type=FAIL
mail_user="NONE"
flag_slurm="OFF"


# SINGULARITY arguments
flag_singularity="ON"
p_singularity_img="NONE"
p_singularity_bindpath="NONE"

# COMPONENTS OF NP3 arguments
flag_run_all="ON"
flag_run_lasso="OFF"
flag_run_bart="OFF"
flag_run_combine="OFF"
flag_run_pwm="OFF"


# ------------------------------------------------------------------------------------- #
# |                   *** Read arguments provided by the user ***                     | #
# ------------------------------------------------------------------------------------- #
while getopts ":hlbcmea-:" OPTION
do
    case "${OPTION}" in
        l)
            flag_run_lasso="ON"
            flag_run_all="OFF"
            ;;
        b)
            flag_run_bart="ON"
            flag_run_all="OFF"
            ;;
        c)
            flag_run_combine="ON"
            flag_run_all="OFF"
            ;;
        m)
            flag_run_pwm="ON"
            flag_run_all="OFF"
             ;;
        h)
            usage
            exit 2
            ;;
        -)
            case "${OPTARG}" in
                # Input
                p_in_binding_event)
                  p_in_binding_event="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                p_in_expr_target)
                  p_in_expr_target="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                p_in_expr_reg)
                  p_in_expr_reg="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                p_in_net_de)
                  p_in_net_de="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  l_in_name_net+="de"
                  l_in_path_net+="${p_in_net_de}"
                  ;;
                seed)
                  seed="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
        
                # Output
                p_out_dir)
                  p_out_dir="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                  
                # LASSO
                flag_local_shrinkage)
                  flag_local_shrinkage="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                flag_global_shrinkage)
                  flag_global_shrinkage="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                flag_microarray)
                  flag_microarray="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                lasso_nbr_fold)
                    lasso_nbr_fold="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                lasso_slurm_nodes)
                    lasso_slurm_nodes="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                    ;;
                lasso_slurm_mem)
                    lasso_slurm_mem="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                    ;;
                    
                # BART
                bart_slurm_nodes)
                    bart_slurm_nodes="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                    ;;
                bart_slurm_ntasks)
                    bart_slurm_ntasks="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                    ;;
                bart_slurm_mem)
                    bart_slurm_mem="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                    ;;
                bart_ntree)
                    bart_ntree="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                    ;;
                    
                # PWM
                p_in_promoter)
                  p_in_promoter="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                p_in_net_bart)
                  p_in_net_bart="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
               
               # COMBINE
                l_in_name_net)
                  l_in_name_net="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                l_in_path_net)
                  l_in_path_net="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                flag_penalize)
                  flag_penalize="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                penalize_nbr_fold)
                  penalize_nbr_fold="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                flag_training)
                  flag_training="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                combine_cv_nbr_fold)
                  combine_cv_nbr_fold="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                in_model_name)
                  in_model_name="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                flag_intercept)
                  flag_intercept="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                # method: default param
                in_coef)
                  in_coef="${!OPTIND}"; OPTIND=$(( ${OPTIND} + 1 ))
                  ;;
                p_in_model)
                  p_in_model="${!OPTIND}"; OPTIND=$(( ${OPTIND} + 1 ))
                  ;;
                # method: small subset
                in_nbr_reg)
                  in_nbr_reg="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                # COMBINE SLURM
                combine_slurm_nodes)
                  combine_slurm_nodes="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                combine_slurm_ntasks_per_node)
                  combine_slurm_ntasks_per_node="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                combine_slurm_ntasks)
                  combine_slurm_ntasks="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                combine_slurm_cpus_per_task)
                  combine_slurm_cpus_per_task="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                combine_slurm_mem)
                  combine_slurm_mem="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
               
                # Logistics
                p_src_code)
                  p_src_code="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                data)
                  data="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                flag_debug)
                  flag_debug="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                
                # SLURM
                flag_slurm)
                  flag_slurm="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                p_out_dir_logs)
                  p_out_dir_logs="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                mail_type)
                  mail_type="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                mail_user)
                  mail_user="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                  
                # SINGULARITY arguments
                flag_singularity)
                    flag_singularity="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                p_singularity_img)
                    p_singularity_img="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
                p_singularity_bindpath)
                    p_singularity_bindpath="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                  ;;
      esac;;
    

    esac
done

# ======================================================================================================= #
# |                                    **** END PARSE ARGUMENTS ****                                    | #
# ======================================================================================================= #


# ======================================================================================================= #
# |                                     *** BUILD LASSO NETWORK ***                                     | #
# ======================================================================================================= #

mkdir -p ${p_out_dir}

job_id_lasso=1
if [ ${flag_run_lasso} == "ON" ] || [ ${flag_run_all} == "ON" ]
then
    cmd_run_lasso=""
    if [ ${flag_slurm} == "ON" ]; then
        mkdir -p ${p_out_dir_logs}tmp/
        cmd_run_lasso+="sbatch \
                       -o ${p_out_dir_logs}build_lasso_%J.out \
                       -e ${p_out_dir_logs}build_lasso_%J.err \
                       -J ${data}_lasso \
                       --mail-type=${mail_type} \
                       --mail-user=${mail_user} \
                       -D ${p_out_dir_logs}tmp/ \
                       -n 11 \
                       --nodes=1-${lasso_slurm_nodes} \
                       --mem=${lasso_slurm_mem} \
                       --cpus-per-task=2 "
    fi
    cmd_run_lasso+="${p_src_code}src/build_lasso/wrapper/build_net_lasso.sh \
                    ${p_in_expr_target} \
                    ${p_in_expr_reg} \
                    ${flag_global_shrinkage} \
                    ${flag_local_shrinkage} \
                    ${p_out_dir} \
                    net_lasso.tsv \
                    ${flag_debug} \
                    ${flag_slurm} \
                    ${seed} \
                    ${lasso_nbr_fold} \
                    ${flag_microarray} \
                    ${p_src_code} \
                    ${flag_singularity} \
                    ${p_singularity_img} \
                    ${p_singularity_bindpath}"
    
    echo "run LASSO.."                    
    job_id_lasso=$(echo $(eval ${cmd_run_lasso}) | awk '{split($0, a, " "); print a[4]}')
    l_in_name_net+=",lasso"
    l_in_path_net+=",${p_out_dir}net_lasso.tsv"
fi


# ======================================================================================================= #
# |                                      *** BUILD BART NETWORK ***                                     | #
# ======================================================================================================= #
job_id_bart=1
if [ ${flag_run_bart} == "ON" ] || [ ${flag_run_all} == "ON" ]
then
    cmd_run_bart=""
    if [ ${flag_slurm} == "ON" ]; then
        mkdir -p ${p_out_dir_logs}tmp/
        cmd_run_bart+="sbatch \
                       -o ${p_out_dir_logs}build_bart_%J.out \
                       -e ${p_out_dir_logs}build_bart_%J.err \
                       -J ${data}_bart \
                       --mail-type=${mail_type} \
                       --mail-user=${mail_user} \
                       --ntasks=${bart_slurm_ntasks} \
                       --nodes=1-${bart_slurm_nodes} \
                       -D ${p_out_dir_logs}tmp/ \
                       --mem=${bart_slurm_mem} "
    fi
    cmd_run_bart+="${p_src_code}src/build_bart/wrapper/build_net_bart.sh \
                  ${p_in_expr_target} \
                  ${p_in_expr_reg} \
                  ${p_out_dir} \
                  net_bart.tsv \
                  ${bart_ntree} \
                  ${flag_slurm} \
                  ${p_src_code} \
                  ${flag_singularity} \
                  ${p_singularity_img} \
                  ${p_singularity_bindpath} \
                  ${bart_slurm_ntasks}"
    echo "run BART.."
    job_id_bart=$(echo $(eval ${cmd_run_bart}) | awk '{split($0, a, " "); print a[4]}')
    l_in_name_net+=",bart"
    l_in_path_net+=",${p_out_dir}net_bart.tsv"
    p_in_net_bart=${p_out_dir}net_bart.tsv
fi


# ======================================================================================================= #
# |                                     *** BUILD MOTIF NETWORK ***                                     | #
# ======================================================================================================= #

job_id_pwm=1
if [ ${flag_run_pwm} == "ON" ] || [ ${flag_run_all} == "ON" ]
then
    if [ ${flag_slurm} == "ON" ]; then
        mkdir -p ${p_out_dir_logs}tmp/
        nbr_job_pwm=25
        cmd_run_pwm+="sbatch \
                      -o ${p_out_dir_logs}build_pwm_%J.out \
                      -e ${p_out_dir_logs}build_pwm_%J.err \
                      -J ${data}_pwm \
                      --mail-type=${mail_type} \
                      --mail-user=${mail_user} \
                      --nodes=1 \
                      --ntasks=5 \
                      --cpus-per-task=2 \
                      -D ${p_out_dir_logs}tmp/ \
                      --dependency=afterok:${job_id_bart} "
    fi
    cmd_run_pwm+="${p_src_code}src/build_pwm/workflow/build_net_pwm.sh \
                 --p_in_net ${p_in_net_bart} \
                 --p_in_promoter ${p_in_promoter} \
                 --p_out_dir ${p_out_dir} \
                 --f_out_name net_pwm.tsv \
                 --flag_slurm ${flag_slurm} \
                 --flag_singularity ${flag_singularity} \
                 --p_singularity_img ${p_singularity_img} \
                 --p_singularity_bindpath ${p_singularity_bindpath} \
                 --p_src_code ${p_src_code} \
                 --nbr_job ${nbr_job_pwm}"
                 
    echo "run PWM.."             
    job_id_pwm=$(echo $(eval ${cmd_run_pwm}) | awk '{split($0, a, " "); print a[4]}')
    l_in_name_net+=",pwm"
    l_in_path_net+=",${p_out_dir}net_pwm.tsv"
fi


# ======================================================================================================= #
# |                                       *** COMBINE NETWORKS ***                                      | #
# ======================================================================================================= #
job_id_combine=1
if [ ${flag_run_combine} == "ON" ] || [ ${flag_run_all} == "ON" ]
then
    cmd_run_combine=""
    if [ ${flag_slurm} == "ON" ];then
        mkdir -p ${p_out_dir_logs}
        mkdir -p ${p_out_dir_logs}tmp/
        cmd_run_combine+="sbatch \
            -o ${p_out_dir_logs}combine_networks_%J.out \
            -e ${p_out_dir_logs}combine_networks_%J.err \
            -D ${p_out_dir_logs}tmp/ \
            -J ${data}_combine \
            --mail-type=${mail_type} \
            --mail-user=${mail_user} \
            --mem=${combine_slurm_mem} \
            --dependency=afterok:${job_id_pwm}:${job_id_bart}:${job_id_lasso} "
        if [ ${flag_training} == "ON-CV" ]; then
            cmd_run_combine+="--nodes=1-${combine_slurm_nodes} \
                              --cpus-per-task=${combine_slurm_cpus_per_task} \
                              --ntasks-per-node=${combine_slurm_ntasks_per_node} "
        elif [ ${flag_training} == "ON-INT" ]; then
            cmd_run_combine+="--ntasks=${combine_slurm_ntasks} \
                              --nodes=1-${combine_slurm_nodes} "
        elif [ ${flag_training} == "ON-SUB" ]; then
            cmd_run_combine+=""
        fi
    fi
    cmd_run_combine+="${p_src_code}src/combine_networks/workflow/combine_networks.sh \
                      --p_in_binding_event ${p_in_binding_event} \
                      --l_in_name_net ${l_in_name_net} \
                      --l_in_path_net ${l_in_path_net} \
                      --in_nbr_reg ${in_nbr_reg} \
                      --p_in_model ${p_in_model} \
                      --seed ${seed} \
                      --flag_penalize ${flag_penalize} \
                      --flag_training ${flag_training} \
                      --cv_nbr_fold ${combine_cv_nbr_fold} \
                      --p_out_dir ${p_out_dir} \
                      --p_src_code ${p_src_code} \
                      --flag_debug ${flag_debug} \
                      --flag_slurm ${flag_slurm} \
                      --slurm_ntasks_per_node ${combine_slurm_ntasks_per_node} \
                      --slurm_ntasks ${combine_slurm_ntasks} \
                      --slurm_cpus_per_task ${combine_slurm_cpus_per_task} \
                      --slurm_nodes ${combine_slurm_nodes} \
                      --slurm_mem ${combine_slurm_mem} \
                      --flag_singularity ${flag_singularity} \
                      --p_singularity_img ${p_singularity_img} \
                      --p_singularity_bindpath ${p_singularity_bindpath}"
     
    echo "run COMBINE.."  
    job_id_combine=$(echo $(eval ${cmd_run_combine}) | awk '{split($0, a, " "); print a[4]}')
fi