make_proj.pl

#!/usr/bin/perl
 
use strict; use warnings;
use NEURO qw(check_or_make print_help);
 
my $study = shift;
my $src_path = shift;
unless ($study && $src_path) { print_help $ENV{'PIPEDIR'}.'/doc/make_proj.hlp'; exit;}
check_or_make("$ENV{HOME}/.config/neuro");
my $data_dir = "$ENV{PIPEDATA}/$study";
check_or_make("$ENV{PIPEDATA}");
check_or_make("$data_dir");
check_or_make($data_dir.'/working');
check_or_make($data_dir.'/bids');
my $cfg_file = $ENV{HOME}."/.config/neuro/".$study.".cfg";
open DF, ">$cfg_file" or die "$!";
print DF "DATA = $data_dir\n";
print DF "SRC = $src_path\n";
print DF "WORKING = $data_dir/working\n";
print DF "BIDS = $data_dir/bids\n";
close DF;

update_mri_db.pl

#!/usr/bin/perl
 
use strict; use warnings;
use NEURO4 qw(load_project);
 
my $proj = shift;
unless ($proj) { print_help $ENV{'PIPEDIR'}.'/doc/update_db.hlp'; exit;}
my %std = load_study($proj);
my $src_dir = $std{'SRC'};
my $ids_file = $std{'DATA'}.'/ids.csv'; # Este es solo para funcionamiento interno
my $proj_file = $std{'DATA'}.'/'.$proj.'_mri.csv';
 
#Leo los que han subido 
my @orig_str = qx/ls $src_dir/;
chomp @orig_str;
 
#Leo el DB previo
my %idsinfo;
my $idscount;
#Pero solo si existe!
if (-e $ids_file){
        open IDS, "<$ids_file" or die $!;
        while(<IDS>){
                chomp;
                my ($key, $value) = split(/,\s?/);
                $idsinfo{$key} = $value;
                $idscount = $value;
        }
        $idscount++;
        close IDS;
}
 
my @not_in_db = grep !$idsinfo{$_}, @orig_str;
foreach my $guy (@not_in_db) {
        $idsinfo{$guy} = $idscount;
        $idscount++;
}
#Update para todo
open IDS, ">$ids_file" or die $!;
open PDS, ">$proj_file" or die $!;
foreach my $guy (sort {$idsinfo{$a} <=> $idsinfo{$b}} keys %idsinfo) {
        print IDS $guy,",",$idsinfo{$guy},"\n";
        printf PDS "%04d;%s\n", $idsinfo{$guy}, $guy;
}
close PDS;
close IDS;

{
        "descriptions": [
                {        
                        "dataType": "anat",
                        "modalityLabel": "T1w",
                        "criteria": {
                                "SeriesDescription": "MPRAGE_GRAPPA2",
                                "ImageType": ["ORIGINAL", "PRIMARY", "M", "NORM", "DIS3D", "DIS2D", "MFSPLIT"]
                        }
                },
                {        
                        "dataType": "anat",
                        "modalityLabel": "T2w",
                        "criteria": {
                                "SeriesDescription": "3D-T2-FLAIR_SAG*",
                                "ImageType": ["ORIGINAL", "PRIMARY", "M", "NORM", "DIS3D", "DIS2D", "MFSPLIT"]
                        }
                },
                {
                        "dataType": "dwi",
                        "modalityLabel": "dwi",
                        "criteria": {
                                "SeriesDescription": "EPAD-SingleShell-DTI48",
                                "ImageType": ["ORIGINAL", "PRIMARY", "DIFFUSION", "NONE", "ND", "NORM", "MFSPLIT"]
                        }
                },
                {
                        "dataType": "dwi",
                        "modalityLabel": "dwi",
                        "customLabels": "dir-PA_sbref",
                        "criteria": {
                                "SeriesDescription": "EPAD-B0-RevPE"
                        }
 
                },
                {
                        "dataType": "func",
                        "modalityLabel": "bold",
                        "customLabels": "task-rest",
                        "criteria": {
                                "SeriesDescription": "EPAD-rsfMRI*",
                                "ImageType": ["ORIGINAL", "PRIMARY", "M", "ND", "NORM", "MFSPLIT"]
                        }
                },
                {
                        "dataType": "func",
                        "modalityLabel": "bold",
                        "customLabels": "task-rest_dir-PA_sbref",
                        "criteria": {
                                "SeriesDescription": "EPAD-SE-fMRI"
                        }
                },
                {
                        "dataType": "func",
                        "modalityLabel": "bold",
                        "customLabels": "task-rest_dir-AP_sbref",
                        "criteria": {
                                "SeriesDescription": "EPAD-SE-fMRI-RevPE"
                        }
                }
 
        ]
}

[tester@detritus bids]$ dcm2bids -d /nas/tester/testproj/032-00001-SCR-GLOBAL/ -p 0001 -c /nas/data/ptest/bids/conversion.json -o /nas/data/ptest/bids/
INFO:dcm2bids.dcm2bids:--- dcm2bids start ---
INFO:dcm2bids.dcm2bids:OS:version: Linux-2.6.32-431.17.1.el6.centos.plus.x86_64-x86_64-with-centos-6.10-Final
INFO:dcm2bids.dcm2bids:python:version: 3.4.8 (default, Apr  9 2018, 11:43:18) [GCC 4.4.7 20120313 (Red Hat 4.4.7-18)]
INFO:dcm2bids.dcm2bids:dcm2bids:version: 2.1.4
INFO:dcm2bids.dcm2bids:dcm2niix:version: v1.0.20191031
INFO:dcm2bids.dcm2bids:participant: sub-0001
INFO:dcm2bids.dcm2bids:session:
INFO:dcm2bids.dcm2bids:config: /nas/data/ptest/bids/conversion.json
INFO:dcm2bids.dcm2bids:BIDS directory: /nas/data/ptest/bids
INFO:dcm2bids.utils:Running dcm2niix -b y -ba y -z y -f '%3s_%f_%p_%t' -o /nas/data/ptest/bids/tmp_dcm2bids/sub-0001 /nas/tester/testproj/032-00001-SCR-GLOBAL/
INFO:dcm2bids.dcm2niix:Check log file for dcm2niix output
INFO:dcm2bids.sidecar:Sidecars pairing:
............
 
[tester@detritus bids]$ tree sub-0001/
sub-0001/
├── anat
│   ├── sub-0001_T1w.json
│   ├── sub-0001_T1w.nii.gz
│   ├── sub-0001_T2w.json
│   └── sub-0001_T2w.nii.gz
├── dwi
│   ├── sub-0001_dir-PA_sbref_dwi.json
│   ├── sub-0001_dir-PA_sbref_dwi.nii.gz
│   ├── sub-0001_dwi.bval
│   ├── sub-0001_dwi.bvec
│   ├── sub-0001_dwi.json
│   └── sub-0001_dwi.nii.gz
└── func
    ├── sub-0001_task-rest_bold.json
    ├── sub-0001_task-rest_bold.nii.gz
    ├── sub-0001_task-rest_dir-AP_sbref_bold.json
    ├── sub-0001_task-rest_dir-AP_sbref_bold.nii.gz
    ├── sub-0001_task-rest_dir-PA_sbref_bold.json
    └── sub-0001_task-rest_dir-PA_sbref_bold.nii.gz
 
3 directories, 16 files 

bulk2bids.pl

#!/usr/bin/perl
 
use strict; use warnings;
use NEURO4 qw(load_project print_help populate check_or_make);
 
my $cfile = 'bids/conversion.json';
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-c/) { $cfile = shift; chomp($cfile);}
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/bulk2bids.hlp'; exit;}
}
my $proj  = shift;
unless ($proj) { print_help $ENV{'PIPEDIR'}.'/doc/bulk2bids.hlp'; exit;}
my %std = load_project($proj);
my $src_dir = $std{'SRC'};
my $proj_file = $std{'DATA'}.'/'.$proj.'_mri.csv';
my %guys = populate('^(\d{4});(.*)$', $proj_file);
my $outdir = "$std{'DATA'}/slurm";
check_or_make($outdir);
foreach my $subject (sort keys %guys) {
        my $order = 'dcm2bids -d '.$std{'SRC'}.'/'.$guys{$subject}.'/ -p '.$subject.' -c '.$std{'DATA'}.'/'.$cfile.' -o '.$std{'DATA'}.'/bids/';
        #print "$order\n";
        my $orderfile = $outdir.'/'.$subject.'dcm2bids.sh';
        open ORD, ">$orderfile";
        print ORD '#!/bin/bash'."\n";
        print ORD '#SBATCH -J dcm2bids_'.$proj."\n";
        print ORD '#SBATCH --time=2:0:0'."\n"; #si no ha terminado en X horas matalo
        print ORD '#SBATCH --mail-type=FAIL,TIME_LIMIT,STAGE_OUT'."\n"; #no quieres que te mande email de todo
        print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
        print ORD '#SBATCH -o '.$outdir.'/dcm2bids'.$subject.'-%j'."\n";
        print ORD "srun $order\n";
        close ORD;
        system("sbatch $orderfile");
}
my $orderfile = $outdir.'/dcm2bids_end.sh';
open ORD, ">$orderfile";
print ORD '#!/bin/bash'."\n";
print ORD '#SBATCH -J dcm2bids_'.$proj."\n";
print ORD '#SBATCH --mail-type=END'."\n"; #email cuando termine o falle
print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
print ORD '#SBATCH -o '.$outdir.'/dmc2bids_end-%j'."\n";
print ORD ":\n";
close ORD;
my $xorder = 'sbatch --dependency=singleton'.' '.$orderfile;
exec($xorder);

precon.pl

#!/usr/bin/perl
 
use strict; use warnings;
use File::Basename qw(basename);
use Data::Dump qw(dump);
 
use NEURO4 qw(populate check_subj load_project print_help check_or_make get_subjects get_list);
 
my $attach = 0;
my $cfile;
 
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-a/) { $attach = 1;}
    if (/^-cut/) { $cfile = shift; chomp($cfile);}
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/recon.hlp'; exit;}
}
 
my $study = shift;
unless ($study) { print_help $ENV{'PIPEDIR'}.'/doc/recon.hlp'; exit;}
my $debug = 1;
my $stage = "-autorecon-all";
my %std = load_project($study);
my $data_dir=$std{'DATA'};
my $mri_db = $std{'DATA'}.'/'.$study.'_mri.csv';
my $bids_path = $std{'DATA'}.'/bids';
#open debug file
my $logfile = "$std{'DATA'}/.debug.controlled.log";
$debug ? open DBG, ">$logfile" :0;
#open slurm file
my $orderfile = "$std{'DATA'}/mri_orders.sh";
my $conffile = "$std{'DATA'}/mri_orders.conf";
my $outdir = "$std{'DATA'}/slurm";
check_or_make($outdir);
 
#get subjects from database or file
my @plist;
my @iplist = get_subjects($mri_db);
 
if ($cfile){
        my @cuts = get_list($data_dir."/".$cfile);
        foreach my $cut (sort @cuts){
                if(grep {/$cut/} @iplist){
                        push @plist, $cut;
                }
        }
}else{
        @plist = @iplist;
}
foreach my $pkey (sort @plist){
        my $subj = $study."_".$pkey;
        my %nifti = check_subj($std{'DATA'},$subj);
        if($nifti{'T1w'}){
                my $order;
                if($nifti{'T2w'}){
                        $order = "recon-all ".$stage." -i ".$nifti{'T1w'}." -T2 ".$nifti{'T2w'}." -subjid ".$subj;
                }else{
                        $order = "recon-all ".$stage." -i ".$nifti{'T1w'}." -subjid ".$subj;
                }
                my $orderfile = $outdir.'/'.$subj.'fs_orders.sh';
                open ORD, ">$orderfile";
                print ORD '#!/bin/bash'."\n";
                print ORD '#SBATCH -J fs_recon_'.$study."\n";
                print ORD '#SBATCH --time=48:0:0'."\n"; #si no ha terminado en X horas matalo
                print ORD '#SBATCH --mail-type=FAIL,TIME_LIMIT,STAGE_OUT'."\n"; #no quieres que te mande email de todo
                print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
                print ORD '#SBATCH -p fast'."\n";
                print ORD '#SBATCH -o '.$outdir.'/fs_recon-slurm-'.$subj.'-%j'."\n";
                print ORD "srun $order\n";
                close ORD;
                system("sbatch $orderfile");
        }
}
 
$debug ? close DBG:0;
$orderfile = $outdir.'/fs_recon_end.sh';
open ORD, ">$orderfile";
print ORD '#!/bin/bash'."\n";
print ORD '#SBATCH -J fs_recon_'.$study."\n";
print ORD '#SBATCH --mail-type=END'."\n"; #email cuando termine
print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
print ORD '#SBATCH -o '.$outdir.'/fs_recon_end-%j'."\n";
print ORD ":\n";
close ORD;
my $order = 'sbatch --dependency=singleton '.$orderfile;
exec($order);

fs_metrics.pl

#!/usr/bin/perl
 
use strict; use warnings;
use NEURO4 qw(get_subjects check_fs_subj load_project print_help shit_done check_or_make);
use FSMetrics qw(fs_file_metrics);
use File::Basename qw(basename);
 
my $attach = 1;
# print help if called without arguments
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-l/) { $attach = 0;}
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/fs_metrics.hlp'; exit;}
}
 
my $study = shift;
unless ($study) { print_help $ENV{'PIPEDIR'}.'/doc/fs_metrics.hlp'; exit;}
my %std = load_project($study);
my $db = $std{DATA}.'/'.$study.'_mri.csv';
my $fsout = $std{DATA}.'/fsrecon';
check_or_make($fsout);
my @plist = get_subjects($db);
my $subj_dir = $ENV{'SUBJECTS_DIR'};
my %stats = fs_file_metrics();
 
my @fspnames;
foreach my $pkey (@plist){
        my $subj = $study."_".$pkey;
        if(check_fs_subj($subj)){
                push @fspnames, $subj;
        }
}
my $fslist = join ' ', @fspnames;
foreach my $stat (sort keys %stats) {
        if(exists($stats{$stat}{'active'}) && $stats{$stat}{'active'}){
                (my $order = $stats{$stat}{'order'}) =~ s/<list>/$fslist/;
                 $order =~ s/<fs_output>/$fsout/;
                system("$order");
                (my $opatt = $stat) =~ s/_/./g;
                $opatt =~ s/(.*)\.rh$/rh\.$1/;
                $opatt =~ s/(.*)\.lh$/lh\.$1/;
                $order = 'sed \'s/\t/,/g; s/ptest_//;s/^Measure:volume\|^'.$opatt.'/Subject/\' '.$fsout.'/'.$stat.'.txt > '.$fsout.'/'.$stat.'.csv'."\n";
                system($order);
        }
}
 
my $zfile=$std{DATA}."/".$study."_mri_results.tgz";
system("tar czf $zfile $fsout");
shit_done basename($ENV{_}), $study, $zfile;

dti_reg.pl

#!/usr/bin/perl
 
use strict; use warnings;
use File::Slurp qw(read_file);
use File::Find::Rule;
use File::Basename qw(basename);
use Data::Dump qw(dump);
use File::Copy::Recursive qw(dirmove);
 
use NEURO4 qw(get_subjects check_subj load_project print_help get_list check_or_make cut_shit);
 
my $study;
my $cfile;
my $debug=0;
my $old=0;
my $chop=0;
my $timeout='8:0:0';
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-cut/) { $cfile = shift; chomp($cfile);}
    if (/^-old/) {$old=1;}
    if (/^-chop/) {$old=1; $chop=1;}
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/dti_reg.hlp'; exit;}
}
$study = shift;
unless ($study) { print_help $ENV{'PIPEDIR'}.'/doc/dti_reg.hlp'; exit;}
 
my %std = load_project($study);
 
my $subj_dir = $ENV{'SUBJECTS_DIR'};
my $pipe_dir = $ENV{'PIPEDIR'};
# Redirect ouput to logfile (do it only when everything is fine)
my $logfile = "$std{'DATA'}/.debug_dti_register.log";
open STDOUT, ">$logfile" or die "Can't redirect stdout";
open STDERR, ">&STDOUT" or die "Can't dup stdout";
$debug ? open DBG, ">$logfile" :0;
 
my $w_dir=$std{'WORKING'};
my $bids_dir=$std{'BIDS'};
my $db = $std{'DATA'}.'/'.$study.'_mri.csv';
my $data_dir=$std{'DATA'};
 
my $outdir = "$std{'DATA'}/slurm";
check_or_make($outdir);
 
print "Collecting needed files\n";
 
my @dtis = cut_shit($db, $data_dir."/".$cfile);
 
foreach my $subject (sort @dtis){
	if($subject){
		my %nifti = check_subj($std{'DATA'},$subject);
		if($nifti{'T1w'} && $nifti{'dwi'}){
			my $order;
			if($old){
				if($chop){
					$order = $pipe_dir."/bin/dti_proc_x.sh ".$study." ".$subject." ".$nifti{'dwi'}." ".$nifti{'T1w'}." ".$w_dir;
				}else{
					$order = $pipe_dir."/bin/dti_proc_deprecated.sh ".$subject." ".$nifti{'dwi'}." ".$w_dir;
				}
			}else{
				if($nifti{'dwi_sbref'}){
       		                	$order = $pipe_dir."/bin/dti_proc_epi.sh ".$study." ".$subject." ".$nifti{'dwi'}." ".$nifti{'dwi_sbref'}." ".$nifti{'T1w'}." ".$w_dir;
       		                }else{
                                	$order = $pipe_dir."/bin/dti_proc_uncorr.sh ".$study." ".$subject." ".$nifti{'dwi'}." ".$nifti{'T1w'}." ".$w_dir;
                        	}
			}
			my $orderfile = $outdir.'/'.$subject.'dti_orders.sh';
			open ORD, ">$orderfile";
			print ORD '#!/bin/bash'."\n";
			print ORD '#SBATCH -J dti_reg_'.$study."\n";
			print ORD '#SBATCH --time='.$timeout."\n"; #si no ha terminado en X horas matalo
			print ORD '#SBATCH -c 4'."\n";
			print ORD '#SBATCH --mail-type=FAIL,STAGE_OUT'."\n"; #no quieres que te mande email de todo
			print ORD '#SBATCH -o '.$outdir.'/dti_reg-slurm-%j'."\n";
			unless($old){ print ORD '#SBATCH --gres=gpu:1'."\n"; }
			print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
			unless($old){ print ORD '#SBATCH -p cuda'."\n"; }else{print ORD '#SBATCH -p fast'."\n";}
			print ORD "srun $order\n";
			close ORD;
			system("sbatch $orderfile");
			$debug ? print DBG "$order\n" :0;
		}
	}
}
$debug ? close DBG:0;  
my $orderfile = $outdir.'/dti_reg_end.sh';
open ORD, ">$orderfile";
print ORD '#!/bin/bash'."\n";
print ORD '#SBATCH -J dti_reg_'.$study."\n";
print ORD '#SBATCH --mail-type=END'."\n"; #email cuando termine
print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
print ORD '#SBATCH -o '.$outdir.'/dti_reg_end-%j'."\n";
print ORD ":\n";
close ORD;
my $order = 'sbatch --dependency=singleton '.$orderfile;
exec($order);

dt_proc_epi.sh

#!/bin/sh 
 
Usage() {  
    echo "" 
    echo "Usage: dti_proc_epi.sh  <study> <subject> <dwi> <dwi_pa> <T1> <output_dir>"  
    echo ""  
    echo "You must have FSL installed in order to run this script" 
    echo "" 
    exit 1 
} 
 
[ "$6" = "" ] && Usage 
debug=1
study=$1
shift
b_in=$1
shift  
in=`${FSLDIR}/bin/remove_ext $1` 
shift
p2a=`${FSLDIR}/bin/remove_ext $1`
shift  
t1=`${FSLDIR}/bin/remove_ext $1` 
shift  
out=$1 
shift  
td=${out}'/.tmp_'${b_in}  
if [ ! -d "$out" ]; then
        mkdir $out
fi
if [ ! -d "$td" ]; then
        mkdir $td
fi
echo "DTI preproccessing begins on ${b_in} ..." 
echo [`date`] 
echo 
${FSLDIR}/bin/fslroi $in ${td}/a2p_b0 0 1
echo "Preparing topup"
${FSLDIR}/bin/fslmerge -t ${td}/a2p_p2a_b0 ${td}/a2p_b0 ${p2a}
echo "Running topup"
${FSLDIR}/bin/topup --imain=${td}/a2p_p2a_b0 --datain=${out}/../acqparams.txt --out=${td}/topup_results --iout=${td}/hifi_b0
${FSLDIR}/bin/fslmaths ${td}/hifi_b0 -Tmean ${td}/hifi_b0
${FSLDIR}/bin/bet ${td}/hifi_b0 ${td}/hifi_b0_brain -m
echo "Copying files for ${b_in} to ${td}/"  
echo  
cp ${in}.bval ${td}/bvals
cp ${in}.bvec ${td}/bvecs 
echo "Doing correction on ${td}/${b_in}_hifi"  
echo [`date`]
echo  
${FSLDIR}/bin/eddy_cuda --imain=${in} --mask=${td}/hifi_b0_brain --acqp=${out}/../acqparams.txt --index=${out}/../dti_index.txt --bvecs=${td}/bvecs --bvals=${td}/bvals --topup=${td}/topup_results --out=${td}/data 
echo "Running dtifit on ${td}/data" 
echo [`date`]
echo 
${FSLDIR}/bin/dtifit --data=${td}/data --out=${td}/dti --mask=${td}/hifi_b0_brain --bvecs=${td}/bvecs --bvals=${td}/bvals                                                
echo "I will copy all output files to ${out}/${b_in}_XXXXX" 
echo  
for x in ${td}/dti*; do ${FSLDIR}/bin/imcp ${x} ${out}/${b_in}_$(basename $x); done; 
${FSLDIR}/bin/imcp ${td}/hifi_b0_brain ${out}/${b_in}_dti_brain_mask  
${FSLDIR}/bin/imcp ${td}/data ${out}/${b_in}_dti_data  
echo "I need the T1 image"  
${FSLDIR}/bin/fslreorient2std ${t1} ${out}/${b_in}_t1_reoriented  
echo "I get the extracted brain"
${FREESURFER_HOME}/bin/mri_vol2vol --mov ${SUBJECTS_DIR}/${study}_${b_in}/mri/brain.mgz --targ ${SUBJECTS_DIR}/${study}_${b_in}/mri/rawavg.mgz --regheader --o ${td}/${b_in}_tmp_brain_in_rawavg.mgz
${FREESURFER_HOME}/bin/mri_convert --in_type mgz --out_type nii ${td}/${b_in}_tmp_brain_in_rawavg.mgz ${td}/${b_in}_tmp_brain.nii.gz
${FSLDIR}/bin/fslreorient2std ${td}/${b_in}_tmp_brain ${out}/${b_in}_brain
echo "Calculating transformation from MNI to T1"
echo [`date`]
echo
antsRegistrationSyN.sh -d 3 -f ${out}/${b_in}_t1_reoriented.nii.gz -m ${FSLDIR}/data/standard/MNI152_T1_1mm.nii.gz -o ${td}/${b_in}_mni_t1_warp
antsApplyTransforms -d 3 -i ${FSLDIR}/data/standard/MNI152_T1_1mm.nii.gz -r ${out}/${b_in}_t1_reoriented.nii.gz -t ${td}/${b_in}_mni_t1_warp1Warp.nii.gz -t ${td}/${b_in}_mni_t1_warp0GenericAffine.mat -o ${td}/${b_in}_mni_t1_warped.nii.gz
echo "Calculating transformation from T1 to B0"                                                       
echo [`date`]
echo
${FSLDIR}/bin/epi_reg --epi=${out}/${b_in}_dti_data --t1=${out}/${b_in}_t1_reoriented --t1brain=${out}/${b_in}_brain --out=${td}/${b_in}_tmp_diff2std
${FSLDIR}/bin/convert_xfm -omat ${td}/${b_in}_tmp_std2diff.mat -inverse ${td}/${b_in}_tmp_diff2std.mat
c3d_affine_tool -ref ${td}/hifi_b0.nii.gz -src ${out}/${b_in}_t1_reoriented.nii.gz ${td}/${b_in}_tmp_std2diff.mat -fsl2ras -oitk ${td}/${b_in}_epi_reg_ANTS.mat
antsApplyTransforms -d 3 -i ${out}/${b_in}_t1_reoriented.nii.gz -r ${td}/hifi_b0.nii.gz -t ${td}/${b_in}_epi_reg_ANTS.mat -o ${out}/${b_in}_t1_b0.nii.gz
antsApplyTransforms -d 3 -i ${td}/${b_in}_mni_t1_warped.nii.gz -r ${td}/hifi_b0.nii.gz -t ${td}/${b_in}_epi_reg_ANTS.mat -o ${out}/${b_in}_mni_to_b0.nii.gz
echo "Applying transformations to JHU Atlas (ICBM-labels)"
antsApplyTransforms -d 3 -i ${FSLDIR}/data/atlases/JHU/JHU-ICBM-labels-1mm.nii.gz -r ${out}/${b_in}_t1_reoriented.nii.gz -t ${td}/${b_in}_mni_t1_warp1Warp.nii.gz -t ${td}/${b_in}_mni_t1_warp0GenericAffine.mat -o ${td}/${b_in}_JHU_labels_tmp.nii.gz
antsApplyTransforms -d 3 -i ${td}/${b_in}_JHU_labels_tmp.nii.gz -r ${td}/hifi_b0.nii.gz -t ${td}/${b_in}_epi_reg_ANTS.mat -o ${out}/${b_in}_JHU_labels.nii.gz
echo "Applying transformations to JHU Atlas (ICBM-tracts)"
antsApplyTransforms -d 3 -i ${FSLDIR}/data/atlases/JHU/JHU-ICBM-tracts-maxprob-thr25-1mm.nii.gz -r ${out}/${b_in}_t1_reoriented.nii.gz -t ${td}/${b_in}_mni_t1_warp1Warp.nii.gz -t ${td}/${b_in}_mni_t1_warp0GenericAffine.mat -o ${td}/${b_in}_JHU_tracts_tmp.nii.gz
antsApplyTransforms -d 3 -i ${td}/${b_in}_JHU_tracts_tmp.nii.gz -r ${td}/hifi_b0.nii.gz -t ${td}/${b_in}_epi_reg_ANTS.mat -o ${out}/${b_in}_JHU_tracts.nii.gz
${FSLDIR}/bin/imcp ${td}/hifi_b0 ${out}/${b_in}_hifi_b0
echo "Game over :-P"
echo [`date`]
exit 0

make_dti_report.pl

#!/usr/bin/perl
 
use strict; use warnings;
use File::Slurp qw(read_file);
use File::Find::Rule;
use File::Basename qw(basename);
use Data::Dump qw(dump);
use File::Copy::Recursive qw(dirmove);
 
use NEURO4 qw(load_project print_help shit_done);
 
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/make_dti_report.hlp'; exit;}
}
my $study = shift;
unless ($study) { print_help $ENV{'PIPEDIR'}.'/doc/make_dti_report.hlp'; exit;}
my %std = load_project($study);
my $w_dir=$std{'WORKING'};
my $d_dir=$std{'DATA'};
 
# Redirect ouput to logfile (do it only when everything is fine)
my $debug = "$d_dir/.debug_report.log";
open STDOUT, ">$debug" or die "Can't redirect stdout";
open STDERR, ">&STDOUT" or die "Can't dup stdout";
 
my $order = "slicesdir -o ";
my @names = find(file => 'name' => "*mni_to_b0.nii.gz", in => $w_dir);
foreach my $name (sort @names){
	(my $warped = $name) =~ s/mni_to_b0/hifi_b0/; 
	$order .= $warped.' '.$name." ";
}
chdir $w_dir;
system($order);
print "$order\n";
dirmove('slicesdir', 'dtis');

dti_metrics.pl

#!/usr/bin/perl
 
use strict; use warnings;
use File::Find::Rule;
use NEURO qw(get_subjects print_help get_pair get_list load_project shit_done);
use Data::Dump qw(dump);
use File::Basename qw(basename);
 
my $with_sd = 0;
my $atlas = 2;
my $cfile;
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-a1/) { $atlas = 1;}
    if (/^-a2/) { $atlas = 2;}
    if (/^-cut/) { $cfile = shift; chomp($cfile);} 
    if (/^-sd/) { $with_sd = 1;}
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/dti_metrics.hlp'; exit;}
}
 
my $study = shift;
unless ($study) { print_help $ENV{'PIPEDIR'}.'/doc/dti_metrics.hlp'; exit;}
my %std = load_project($study);
 
my $w_dir=$std{'WORKING'};
my $data_dir=$std{'DATA'};
my $db = $std{'DATA'}.'/'.$study.'_mri.csv';
my $roi_list;
my $roi_group;
if($atlas==1){
	$roi_list = $ENV{'PIPEDIR'}.'/lib/jhu.labels.list';
	$roi_group = "labels";
}elsif($atlas==2){
	$roi_list = $ENV{'PIPEDIR'}.'/lib/jhu.tracts.list';
	$roi_group = "tracts";
}
my $roi_dir = $ENV{'PIPEDIR'}.'/lib/jhu/';
my $jhu = "JHU_".$roi_group;
my %masks = get_pair $roi_list;
print "Collecting needed files\n";
 
my @dtis = cut_shit($db, $data_dir."/".$cfile);
 
my %csv;
 
my $ofile = $data_dir."/".$study."_dti_".$roi_group.".csv";
open OF, ">$ofile";
 
print OF "Subject";
foreach my $rmask (sort keys %masks){
	if($with_sd){
		print OF ";$masks{$rmask}","_FA_Mean;","$masks{$rmask}","_FA_STD",";$masks{$rmask}","_MD_Mean;","$masks{$rmask}","_MD_STD";
	}else{
		print OF ";$masks{$rmask}","_FA",";$masks{$rmask}","_MD";
	}
}
print OF "\n";
 
foreach my $subject (@dtis){
        my $dti_fa = $w_dir.'/'.$subject.'_dti_FA.nii.gz';
        my $dti_md = $w_dir.'/'.$subject.'_dti_MD.nii.gz';	
	if($subject){
		foreach my $rmask (sort keys %masks){
			my ($m_index) = $rmask =~ /.*_(\d+)$/;
			if($m_index){
				my $order = "fslmaths ".$w_dir."/".$subject."_".$jhu." -uthr ".$m_index." -thr ".$m_index." -div ".$m_index." ".$w_dir."/.tmp_".$subject."/JHU_".$rmask."_tmp";
			print "$order\n";
			system($order);
			} else {
			my $order = "fslmaths ".$w_dir."/".$subject."_".$jhu." -uthr ".$m_index." -thr ".$m_index." ".$w_dir."/.tmp_".$subject."/JHU_".$rmask."_tmp";               
                        print "$order\n";
                        system($order);
			}
		}
		print OF "$subject";
		foreach my $rmask (sort keys %masks){
			my $order = "fslstats ".$dti_fa." -k ".$w_dir."/.tmp_".$subject."/JHU_".$rmask."_tmp -M -S";
			print "$order\n";
			(my $mean, my $std) = map{/(\d+\.\d*)\s*(\d+\.\d*)/} qx/$order/;
			if($with_sd){
				print OF ";$mean",";$std";
			}else{
				print OF ";$mean";
			}
                        $order = "fslstats ".$dti_md." -k ".$w_dir."/.tmp_".$subject."/JHU_".$rmask."_tmp -M -S";
                        print "$order\n";
                        ($mean, $std) = map{/(\d+\.\d*)\s*(\d+\.\d*)/} qx/$order/;
                        if($with_sd){
                                print OF ";$mean",";$std";
                        }else{
                                print OF ";$mean";
                        }                        
		}
		print OF "\n";
	}
}
 
close OF;
my $zfile=$std{DATA}."/".$study."_dti_".$roi_group."_results.tgz";
system("tar czf $zfile $ofile");
shit_done basename($ENV{_}), $study, $zfile;

dti_bedtrack_cuda.sh

#!/bin/sh
 
Usage() {                      
    echo ""                                                                                                                                                              
    echo "Usage: dti_bedtrack.sh  <project> <subject> <working dir>" 
    echo ""                                                                                                                                                              
    echo "You must have FSL installed in order to run this script"                                                                                                       
    echo ""                                                                                                                                                              
    exit 1                                                                                                                                                               
}                                                                                                                                                                        
 
[ "$3" = "" ] && Usage
debug=1
prj=$1
shift
pollo=$1
shift
w_dir=$1
shift
 
td=${w_dir}'/.tmp_'${pollo}
bd=${td}'/bedpostx'
list=${w_dir}'/../dti_track.seed'
if [ ! -d "$bd" ]; then                                                                                                                                                  
        mkdir $bd                                                                                                                                                        
fi 
echo "Copying files"
${FSLDIR}/bin/imcp ${w_dir}/${pollo}_dti_data ${bd}/data
${FSLDIR}/bin/imcp ${w_dir}/${pollo}_dti_brain_mask ${bd}/nodif_brain_mask
cp ${td}/bvecs ${bd}/bvecs
cp ${td}/bvals ${bd}/bvals
echo "Making bedpostx"
echo [`date`]
${FSLDIR}/bin/bedpostx_gpu ${bd}
echo "So far, so good"
echo [`date`]
echo "Getting aseg"
${PIPEDIR}/bin/get_aparc.sh ${prj} ${pollo} ${w_dir}
antsApplyTransforms -d 3 -i ${w_dir}/${pollo}_aseg.nii.gz -r ${td}/hifi_b0.nii.gz -t ${td}/${pollo}_epi_reg_ANTS.mat -o ${td}/${pollo}_aseg_warped.nii.gz
#WarpImageMultiTransform 3 ${w_dir}/${pollo}_aseg.nii.gz ${td}/${pollo}_aseg_warped.nii.gz -R ${td}/hifi_b0.nii.gz ${td}/${pollo}_dti_t1_b0Warp.nii.gz ${td}/${pollo}_dti_t1_b0Affine.txt
###########################################
######## Falta calcular las mascaras ######
###########################################
for x in `awk NF $list`; do
	${FSLDIR}/bin/fslmaths ${td}/${pollo}_aseg_warped -uthr ${x} -thr ${x} -div ${x} ${td}/${pollo}_mask_${x};
	echo "${td}/${pollo}_mask_${x}.nii.gz" >> ${td}/${pollo}_mask.list;
done;
###########################################		
echo "Doing probtrackx"
probtrackx2 --opd --forcedir -s ${bd}.bedpostX/merged -m ${w_dir}/${pollo}_dti_brain_mask -x ${td}/${pollo}_mask.list --dir=${td}/probtrack_out
rm ${td}/${pollo}_mask.list;
mv ${td}/probtrack_out ${w_dir}/${pollo}_probtrack_out
echo "Done"
echo [`date`]

dti_track.pl

#!/usr/bin/perl
 
use strict; use warnings;
use File::Slurp qw(read_file);
use File::Find::Rule;
use File::Basename qw(basename);
use Data::Dump qw(dump);
use File::Copy::Recursive qw(dirmove);
use NEURO4 qw(load_project print_help cut_shit check_or_make);
 
my $study;
my $cfile;
my $debug=1;
my $atlas=0; 
my $network;
my $t1=0;
my $time = '8:0:0';
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-cut/) { $cfile = shift; chomp($cfile);}
    if (/^-t1/) {$t1 = 1;}
    if (/^-time/) {$time = shift; chomp($time)}
    if (/^-uofm/) {$atlas="uofm"; $network = shift; chomp($network); $network =~ s/\_/\//g;}
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/dti_track.hlp'; exit;}
}
$study = shift;
unless ($study) { print_help $ENV{'PIPEDIR'}.'/doc/dti_track.hlp'; exit;}
 
my %std = load_project($study);
my $subj_dir = $ENV{'SUBJECTS_DIR'};
my $pipe_dir = $ENV{'PIPEDIR'};
# Redirect ouput to logfile (do it only when everything is fine)
my $logfile = "$std{'DATA'}/.debug_dti_tracks.log";
open STDOUT, ">$logfile" or die "Can't redirect stdout";
open STDERR, ">&STDOUT" or die "Can't dup stdout";
$debug ? open DBG, ">$logfile" :0;
 
my $w_dir=$std{'WORKING'};
my $data_dir=$std{'DATA'};
my $db = $data_dir.'/'.$study.'_mri.csv';
my $outdir = "$std{'DATA'}/slurm";
check_or_make($outdir);
 
my @dtis = cut_shit($db, $data_dir.'/'.$cfile);
foreach my $subject (@dtis){
	#Compulsory: el DTI debe haber pasado el preproc
	my $dti_fa = $w_dir.'/'.$subject.'_dti_FA.nii.gz';
	#Compulsory: Necesito tambien la segmentacion de freesurfer de este pollo
	my $aseg = $subj_dir.'/'.$study.'_'.$subject.'/mri/aseg.mgz';
	if((-e $dti_fa) && (-e $aseg)){
		my $order;
		unless($atlas){
			if($t1){
				$order = $pipe_dir."/bin/dti_bedtrack_cuda_t1.sh ".$study." ".$subject." ".$w_dir;
			}else{
				$order = $pipe_dir."/bin/dti_bedtrack_cuda.sh ".$study." ".$subject." ".$w_dir;
			}
		}else{
			if($t1){
				$order = $pipe_dir."/bin/dti_bedtrack_nodes_t1.sh ".$study." ".$subject." ".$w_dir." ".$pipe_dir."/lib/".$atlas."/Nodes/".$network;
			}else{
				$order = $pipe_dir."/bin/dti_bedtrack_nodes.sh ".$study." ".$subject." ".$w_dir." ".$pipe_dir."/lib/".$atlas."/Nodes/".$network;
			}
		}
		#$count++;
		#print CNF "$order\n";
		my $orderfile = $outdir.'/'.$subject.'dti_orders.sh';
		open ORD, ">$orderfile";
		print ORD '#!/bin/bash'."\n";
		print ORD '#SBATCH -J dti_track_'.$study."\n";
		print ORD '#SBATCH --time='.$time."\n"; #si no ha terminado en X horas matalo
		print ORD '#SBATCH --mail-type=FAIL,TIME_LIMIT,STAGE_OUT'."\n"; #no quieres que te mande email de todo
		print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
		print ORD '#SBATCH --gres=gpu:1'."\n";
		print ORD '#SBATCH -o '.$outdir.'/dti_track-'.$subject.'-'.$study.'-%j'."\n";
		print ORD '#SBATCH -p cuda'."\n";
		print ORD "srun $order\n";
        	close ORD;
		system("sbatch $orderfile")
		$debug ? print DBG "$order\n" :0;
	}
}
 
my $orderfile = $outdir.'/dti_track_end.sh';
open ORD, ">$orderfile";
print ORD '#!/bin/bash'."\n";
print ORD '#SBATCH -J dti_track_'.$study."\n";
print ORD '#SBATCH --mail-type=END'."\n"; #email cuando termine
print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
print ORD '#SBATCH -o '.$outdir.'/dti_track_end-%j'."\n";
print ORD ":\n";
close ORD;
my $order = 'sbatch --dependency=singleton '.$orderfile;
exec($order);

dti_metrics_tracks.pl

#!/usr/bin/perl
 
# Copyright 2019 O. Sotolongo <asqwerty@gmail.com>
 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
use strict; use warnings;
 
use File::Find::Rule;
use NEURO4 qw(print_help load_project cut_shit shit_done);
use Data::Dump qw(dump);
use File::Basename qw(basename);
 
my $with_sd = 0;
my $threshold = 0.25;
my $net_path;
my $cfile = "";
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-thr/) {$threshold = shift;}
    if (/^-path/) {$net_path = shift;}
    if (/^-sd/) { $with_sd = 1;}
    if (/^-cut/) { $cfile = shift; chomp($cfile);}
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/dti_metrics_rois.hlp'; exit;}
}
 
my $study = shift;
$net_path = "out" unless $net_path;
unless ($study) { print_help $ENV{'PIPEDIR'}.'/doc/dti_metrics_rois.hlp'; exit;}
my %std = load_project($study);
 
my $w_dir=$std{'WORKING'};
my $data_dir=$std{'DATA'};
my $db = $data_dir.'/'.$study.'_mri.csv';
print "Collecting needed files\n";
 
my @dtis = cut_shit($db, $data_dir.'/'.$cfile);
 
my $ofile = $data_dir."/".$study."_dti_".$net_path.".csv";
open OF, ">$ofile";
print OF "Subject";
if($with_sd){
	print OF ";$net_path","_FA_Mean;","$net_path","_FA_STD",";$net_path","_MD_Mean;","$net_path","_MD_STD";
}else{
	print OF ";$net_path","_FA",";$net_path","_MD";
}
print OF "\n";
 
foreach my $subject (sort @dtis){
	my $img_path = $w_dir.'/'.$subject.'_probtrack_'.$net_path.'/fdt_paths.nii.gz';
	if(-e $img_path && -f $img_path){
		print OF "$subject";
		my $dti_fa = $w_dir.'/'.$subject.'_dti_FA.nii.gz';
		my $dti_md = $w_dir.'/'.$subject.'_dti_MD.nii.gz';	
		my $order = $ENV{'PIPEDIR'}.'/bin/track2mask.sh '.$img_path.' '.$threshold;
		print "$order\n";
		system($order);
		my $mask_path = $w_dir.'/'.$subject.'_probtrack_'.$net_path.'/fdt_paths_mask.nii.gz'; 
		$order = "fslstats ".$dti_fa." -k ".$mask_path." -M -S";
		print "$order\n";
		(my $mean, my $std) = map{/(\d+\.\d*)\s*(\d+\.\d*)/} qx/$order/;
		if($with_sd){
			print OF ";$mean",";$std";
		}else{
			print OF ";$mean";
		}
		$order = "fslstats ".$dti_md." -k ".$mask_path." -M -S";
		print "$order\n";
		($mean, $std) = map{/(\d+\.\d*)\s*(\d+\.\d*)/} qx/$order/;
		if($with_sd){
			print OF ";$mean",";$std";
		}else{
			print OF ";$mean";
		}
		print OF "\n";
	}
}
close OF;
 
my $zfile=$std{DATA}."/".$study."_dti_".$net_path."_results.tgz";
system("tar czf $zfile $ofile");
shit_done basename($ENV{_}), $study, $zfile;

rs_ica_one.pl

#!/usr/bin/perl
 
# Copyright 2019 O. Sotolongo <asqwerty@gmail.com>
 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
use strict; use warnings;
use File::Slurp qw(read_file);
use File::Find::Rule;
use File::Basename qw(basename);
use Data::Dump qw(dump);
use File::Copy::Recursive qw(dirmove);
 
use NEURO4 qw(check_subj load_project print_help cut_shit check_or_make);
 
my $study;
my $cfile="";
 
@ARGV = ("-h") unless @ARGV;
while (@ARGV and $ARGV[0] =~ /^-/) {
    $_ = shift;
    last if /^--$/;
    if (/^-cut/) { $cfile = shift; chomp($cfile);}
    if (/^-h/) { print_help $ENV{'PIPEDIR'}.'/doc/dti_ica_one.hlp'; exit;}
}
$study = shift;
unless ($study) { print_help $ENV{'PIPEDIR'}.'/doc/rs_ica_one.hlp'; exit;}
my %std = load_project($study);
 
my $subj_dir = $ENV{'SUBJECTS_DIR'};
my $pipe_dir = $ENV{'PIPEDIR'};
my $fsl = $ENV{'FSLDIR'};
 
my $w_dir=$std{'WORKING'};
my $db = $std{'DATA'}.'/'.$study.'_mri.csv';
my $data_dir=$std{'DATA'};
my $template_file = $pipe_dir.'/lib/fsf/lone_ica_template.fsf';
my $outdir = "$std{'DATA'}/slurm";
check_or_make($outdir);
print "Collecting needed files\n";
my @fmris = cut_shit($db, $data_dir.'/'.$cfile);
my @feats = ("feat1", "feat2", "feat4");
check_or_make($w_dir.'/.files');
system("cp $fsl'/doc/fsl.css' $w_dir'/.files'");
system("cp -r $fsl'/doc/images' $w_dir'/.files/images'");
chdir($w_dir);
foreach my $subject (sort @fmris){
	my %nifti = check_subj($std{'DATA'},$subject);
	if($nifti{'func'}){
		my $output_dir = $w_dir.'/'.$subject.'_rsout';
		check_or_make($output_dir);
		my $data = $w_dir.'/'.$subject.'_rs';
		system("$fsl'/bin/imcp' $nifti{'func'} $data");		 
		my $test_order = $fsl.'/bin/fslinfo '.$data;
		open(my $test_info, '-|', $test_order ) or die $!;
		my %test_data;
		while (<$test_info>){
		        if (/^dim1\s*(\d{1,3}).*/) {$test_data{'dim1'}=$1;}
		        if (/^dim2\s*(\d{1,3}).*/) {$test_data{'dim2'}=$1;}
		        if (/^dim3\s*(\d{1,3}).*/) {$test_data{'dim3'}=$1;}
		        if (/^dim4\s*(\d{1,3}).*/) {$test_data{'dim4'}=$1;}
		        if (/^pixdim4\s*(\d{1,2}\.\d{1,6})/) {$test_data{'tr'}=$1;}
		}		
		my $data_size = $test_data{'dim1'}*$test_data{'dim2'}*$test_data{'dim3'}*$test_data{'dim4'};
		my $data_dir = $data.'.ica';
		my $logs_dir = $data_dir.'/logs';
		my $scripts_dir = $data_dir.'/scripts';
		check_or_make($data_dir);
		check_or_make($logs_dir);
		check_or_make($scripts_dir);
		my $dsg_file = $w_dir.'/'.$subject.'_design.fsf';
		open TPF,"<$template_file";
		open DSG,">$dsg_file";
		while(<TPF>){
			s/<study>/$study/;
			s/<output_dir>/\"$output_dir\"/;
			s/<data_input>/\"$data\"/;
			s/<TR>/$test_data{'tr'}/;
			s/<number_of_slices>/$test_data{'dim4'}/;
			s/<size_of_image>/$data_size/;	
			print DSG;
		}
		close DSG;
		close TPF;
		my $jobid;
		foreach my $feat (sort @feats){
			my $template = $pipe_dir.'/lib/script_templates/'.$feat.'.template';
			my $script = $scripts_dir.'/'.$feat.'.sh';
			open TPF, "<$template";
			open SF, ">$script";
			my $name = $subject;
			while(<TPF>){
				s/<study>/$study/;
				s/<subject>/$name/;
				s/<mailto>/$ENV{'USER'}/;
				s/<out_dir>/$output_dir/;
				s/<design_file>/$dsg_file/;
				s/<data_dir>/$data_dir/g;
				s/<number>/1/;
				s/<TR>/$test_data{'tr'}/;
				print SF;
			}
			close SF;
			close TPF;
			unless($jobid){
				my $order = 'sbatch '.$script;
				print "$order\n";
				$jobid = `$order`;
				$jobid = ( split ' ', $jobid )[ -1 ];
			}else{
				my $order = 'sbatch --depend=afterok:'.$jobid.' '.$script;
				print "$order\n";
				$jobid = `$order`;
				$jobid = ( split ' ', $jobid )[ -1 ];
			}
		}
		$jobid="";
	}
}
my $orderfile = $outdir.'/feat_end.sh';
open ORD, ">$orderfile";
print ORD '#!/bin/bash'."\n";
print ORD '#SBATCH -J feat-'.$study."\n";
print ORD '#SBATCH --mail-type=END'."\n"; #email cuando termine
print ORD '#SBATCH --mail-user='."$ENV{'USER'}\n";
print ORD '#SBATCH -o '.$outdir.'/feat_end-%j'."\n";
print ORD ":\n";
close ORD;
my $order = 'sbatch --dependency=singleton '.$orderfile;
exec($order);