diff --git a/ndmg/utils/make_gtab_and_bmask_test_notebook.ipynb b/ndmg/utils/make_gtab_and_bmask_test_notebook.ipynb
new file mode 100644
index 000000000..56f8cdf7a
--- /dev/null
+++ b/ndmg/utils/make_gtab_and_bmask_test_notebook.ipynb
@@ -0,0 +1,841 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Notebook to test replacement of make_gtab_and_bmask with non_fsl replacements\n",
+    "\n",
+    "## 1) Replace FSL BET with dipy median_ostu\n",
+    "\n",
+    "## 2) Replace FSL ROI with direct python manipulation\n",
+    "\n",
+    "## 3) Replace both\n",
+    "\n",
+    "## 4) Test!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Python location : /Users/wilsontang/anaconda3/bin/python\n",
+      "Python version : 3.6.8 |Anaconda, Inc.| (default, Dec 29 2018, 19:04:46) \n",
+      "[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)]\n",
+      "DiPy version : 1.0.0\n",
+      "Your fsl directory is located here: /usr/local/fsl\n",
+      "Your AFNI directory is located here: /Users/wilsontang/abin/afni\n",
+      "\n",
+      "Beginning ndmg ...\n"
+     ]
+    }
+   ],
+   "source": [
+    "## import libraries\n",
+    "\n",
+    "import ndmg\n",
+    "from ndmg import preproc as mgp\n",
+    "\n",
+    "from ndmg import preproc\n",
+    "from ndmg import register\n",
+    "from ndmg import track\n",
+    "from ndmg import graph\n",
+    "from ndmg.utils import gen_utils\n",
+    "from ndmg.utils import reg_utils\n",
+    "from ndmg.utils import cloud_utils\n",
+    "\n",
+    "from dipy.io import read_bvals_bvecs\n",
+    "from dipy.core.gradients import gradient_table\n",
+    "from nilearn.image import mean_img\n",
+    "\n",
+    "from unittest.mock import Mock\n",
+    "import nibabel as nib\n",
+    "import numpy as np \n",
+    "import pytest\n",
+    "import os\n",
+    "import torch\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import dipy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Replacement Functions for make_gtab_and_bmask\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## functions\n",
+    "def replace_roi_make_gtab_and_bmask(fbval, fbvec, dwi_file, outdir):\n",
+    "    ### Replacement of roi with pure python\n",
+    "    \"\"\"Takes bval and bvec files and produces a structure in dipy format while also using FSL commands\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    fbval : str\n",
+    "        b-value file\n",
+    "    fbvec : str\n",
+    "        b-vector file\n",
+    "    dwi_file : str\n",
+    "        dwi file being analyzed\n",
+    "    outdir : str\n",
+    "        output directory\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    GradientTable\n",
+    "        gradient table created from bval and bvec files\n",
+    "    str\n",
+    "        location of averaged b0 image file\n",
+    "    str\n",
+    "        location of b0 brain mask file\n",
+    "    \"\"\"\n",
+    "    # Use B0's from the DWI to create a more stable DWI image for registration\n",
+    "    nodif_B0 = \"{}/nodif_B0.nii.gz\".format(outdir)\n",
+    "    nodif_B0_bet = \"{}/nodif_B0_bet.nii.gz\".format(outdir)\n",
+    "    nodif_B0_mask = \"{}/nodif_B0_bet_mask.nii.gz\".format(outdir)\n",
+    "\n",
+    "    # loading bvecs/bvals\n",
+    "    print(fbval)\n",
+    "    print(fbvec)\n",
+    "\n",
+    "    #temp adding mgu as import\n",
+    "    bvals, bvecs = read_bvals_bvecs(fbval, fbvec)\n",
+    "\n",
+    "    # Creating the gradient table\n",
+    "    gtab = gradient_table(bvals, bvecs, atol=1.0)\n",
+    "\n",
+    "    # Correct b0 threshold\n",
+    "    gtab.b0_threshold = min(bvals)\n",
+    "\n",
+    "    # Get B0 indices\n",
+    "    B0s = np.where(gtab.bvals == gtab.b0_threshold)[0]\n",
+    "    print(\"%s%s\" % (\"B0's found at: \", B0s))\n",
+    "\n",
+    "    # Show info\n",
+    "    print(gtab.info)\n",
+    "\n",
+    "    # Extract and Combine all B0s collected\n",
+    "    print(\"Extracting B0's...\")\n",
+    "    cmds = []\n",
+    "    B0s_bbr = []\n",
+    "    \n",
+    "    #load target image dwi_file\n",
+    "    dwi_file_loaded = nib.load(dwi_file)\n",
+    "\n",
+    "    #Convert to numpy\n",
+    "    dwi_file_loaded_np = dwi_file_loaded.get_fdata()\n",
+    "\n",
+    "    for B0 in B0s:\n",
+    "        print(B0)\n",
+    "        B0_bbr = \"{}/{}_B0.nii.gz\".format(outdir, str(B0))\n",
+    "        #save the B0th dimension, a 1 dimensional ROI at B0, the voxel corresponding to the B0th\n",
+    "        B0_dwi = dwi_file_loaded_np[:,:,:,B0]\n",
+    "        #convert back to nifti image using the affine of original image\n",
+    "        B0_nifti = nib.Nifti1Image(B0_dwi, dwi_file_loaded.affine)\n",
+    "        #save in path\n",
+    "        nib.save(B0_nifti, B0_bbr)\n",
+    "        #save for mean image later\n",
+    "        B0s_bbr.append(B0_bbr)\n",
+    "#old func\n",
+    "        # cmd = \"fslroi \" + dwi_file + \" \" + B0_bbr + \" \" + str(B0) + \" 1\"\n",
+    "        # cmds.append(cmd)\n",
+    "\n",
+    "\n",
+    "#     for cmd in cmds:\n",
+    "#         print(cmd)\n",
+    "#         os.system(cmd)\n",
+    "\n",
+    "    # Get mean B0\n",
+    "    B0s_bbr_imgs = []\n",
+    "    for B0 in B0s_bbr:\n",
+    "        B0s_bbr_imgs.append(nib.load(B0))\n",
+    "\n",
+    "    mean_B0 = mean_img(B0s_bbr_imgs)\n",
+    "    nib.save(mean_B0, nodif_B0)\n",
+    "\n",
+    "#Get mean B0 brain mask\n",
+    "    cmd = \"bet \" + nodif_B0 + \" \" + nodif_B0_bet + \" -m -f 0.2\"\n",
+    "    os.system(cmd)\n",
+    "\n",
+    "    return gtab, nodif_B0, nodif_B0_mask\n",
+    "\n",
+    "def replace_bet_make_gtab_and_bmask(fbval, fbvec, dwi_file, outdir):\n",
+    "    \"\"\"Takes bval and bvec files and produces a structure in dipy format while also using FSL commands\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    fbval : str\n",
+    "        b-value file\n",
+    "    fbvec : str\n",
+    "        b-vector file\n",
+    "    dwi_file : str\n",
+    "        dwi file being analyzed\n",
+    "    outdir : str\n",
+    "        output directory\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    GradientTable\n",
+    "        gradient table created from bval and bvec files\n",
+    "    str\n",
+    "        location of averaged b0 image file\n",
+    "    str\n",
+    "        location of b0 brain mask file\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Use B0's from the DWI to create a more stable DWI image for registration\n",
+    "    nodif_B0 = \"{}/nodif_B0.nii.gz\".format(outdir)\n",
+    "    nodif_B0_bet = \"{}/nodif_B0_bet.nii.gz\".format(outdir)\n",
+    "    nodif_B0_mask = \"{}/nodif_B0_bet_mask.nii.gz\".format(outdir)\n",
+    "\n",
+    "    # loading bvecs/bvals\n",
+    "    print(fbval)\n",
+    "    print(fbvec)\n",
+    "    bvals, bvecs = read_bvals_bvecs(fbval, fbvec)\n",
+    "\n",
+    "    # Creating the gradient table\n",
+    "    gtab = gradient_table(bvals, bvecs, atol=1.0)\n",
+    "\n",
+    "    # Correct b0 threshold\n",
+    "    gtab.b0_threshold = min(bvals)\n",
+    "\n",
+    "    # Get B0 indices\n",
+    "    B0s = np.where(gtab.bvals == gtab.b0_threshold)[0]\n",
+    "    print(\"%s%s\" % (\"B0's found at: \", B0s))\n",
+    "\n",
+    "    # Show info\n",
+    "    print(gtab.info)\n",
+    "\n",
+    "    # Extract and Combine all B0s collected\n",
+    "    print(\"Extracting B0's...\")\n",
+    "    cmds = []\n",
+    "    B0s_bbr = []\n",
+    "    for B0 in B0s:\n",
+    "        print(B0)\n",
+    "        B0_bbr = \"{}/{}_B0.nii.gz\".format(outdir, str(B0))\n",
+    "        cmd = \"fslroi \" + dwi_file + \" \" + B0_bbr + \" \" + str(B0) + \" 1\"\n",
+    "        cmds.append(cmd)\n",
+    "        B0s_bbr.append(B0_bbr)\n",
+    "\n",
+    "    for cmd in cmds:\n",
+    "        print(cmd)\n",
+    "        os.system(cmd)\n",
+    "\n",
+    "    # Get mean B0\n",
+    "    B0s_bbr_imgs = []\n",
+    "    for B0 in B0s_bbr:\n",
+    "        B0s_bbr_imgs.append(nib.load(B0))\n",
+    "\n",
+    "    mean_B0 = mean_img(B0s_bbr_imgs)\n",
+    "    nib.save(mean_B0, nodif_B0)\n",
+    "    \n",
+    "#old func\n",
+    "# #Get mean B0 brain mask\n",
+    "#     cmd = \"bet \" + nodif_B0 + \" \" + nodif_B0_bet + \" -m -f 0.2\"\n",
+    "#     os.system(cmd)\n",
+    "    \n",
+    "    ### using median_ostu \n",
+    "    \n",
+    "    #extract data from file\n",
+    "    nodif_B0_data = nib.load(nodif_B0)\n",
+    "    nodif_B0_array = nodif_B0_data.get_fdata()\n",
+    "    \n",
+    "    #pass np array into dipy\n",
+    "    nodif_B0_dipy = dipy.segment.mask.median_otsu(nodif_B0_array)\n",
+    "    \n",
+    "    #extract bet and bet_mask\n",
+    "    nodif_B0_dipy_bet = nodif_B0_dipy[0]\n",
+    "    #encode True False as float 0,1\n",
+    "    nodif_B0_dipy_bet_mask = nodif_B0_dipy[1].astype(float)\n",
+    "    \n",
+    "    #apply affine to convert back into nifti image\n",
+    "    nodif_B0_dipy_bet_nifti = nib.Nifti1Image(nodif_B0_dipy_bet, nodif_B0_data.affine)\n",
+    "    nodif_B0_dipy_bet_mask_nifti = nib.Nifti1Image(nodif_B0_dipy_bet_mask, nodif_B0_data.affine)\n",
+    "    \n",
+    "    #store bet and bet_mask at designated locations\n",
+    "    nib.save(nodif_B0_dipy_bet_nifti, nodif_B0_bet)\n",
+    "    nib.save(nodif_B0_dipy_bet_mask_nifti, nodif_B0_mask)\n",
+    "    \n",
+    "    return gtab, nodif_B0, nodif_B0_mask\n",
+    "\n",
+    "def replace_both_make_gtab_and_bmask(fbval, fbvec, dwi_file, outdir):\n",
+    "    \"\"\"Takes bval and bvec files and produces a structure in dipy format while also using FSL commands\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    fbval : str\n",
+    "        b-value file\n",
+    "    fbvec : str\n",
+    "        b-vector file\n",
+    "    dwi_file : str\n",
+    "        dwi file being analyzed\n",
+    "    outdir : str\n",
+    "        output directory\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    GradientTable\n",
+    "        gradient table created from bval and bvec files\n",
+    "    str\n",
+    "        location of averaged b0 image file\n",
+    "    str\n",
+    "        location of b0 brain mask file\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Use B0's from the DWI to create a more stable DWI image for registration\n",
+    "    nodif_B0 = \"{}/nodif_B0.nii.gz\".format(outdir)\n",
+    "    nodif_B0_bet = \"{}/nodif_B0_bet.nii.gz\".format(outdir)\n",
+    "    nodif_B0_mask = \"{}/nodif_B0_bet_mask.nii.gz\".format(outdir)\n",
+    "\n",
+    "    # loading bvecs/bvals\n",
+    "    print(fbval)\n",
+    "    print(fbvec)\n",
+    "    bvals, bvecs = read_bvals_bvecs(fbval, fbvec)\n",
+    "\n",
+    "    # Creating the gradient table\n",
+    "    gtab = gradient_table(bvals, bvecs, atol=1.0)\n",
+    "\n",
+    "    # Correct b0 threshold\n",
+    "    gtab.b0_threshold = min(bvals)\n",
+    "\n",
+    "    # Get B0 indices\n",
+    "    B0s = np.where(gtab.bvals == gtab.b0_threshold)[0]\n",
+    "    print(\"%s%s\" % (\"B0's found at: \", B0s))\n",
+    "\n",
+    "    # Show info\n",
+    "    print(gtab.info)\n",
+    "\n",
+    "    # Extract and Combine all B0s collected\n",
+    "    print(\"Extracting B0's...\")\n",
+    "    cmds = []\n",
+    "    B0s_bbr = []\n",
+    "        #load target image dwi_file\n",
+    "    dwi_file_loaded = nib.load(dwi_file)\n",
+    "\n",
+    "    #Convert to numpy\n",
+    "    dwi_file_loaded_np = dwi_file_loaded.get_fdata()\n",
+    "\n",
+    "    for B0 in B0s:\n",
+    "        print(B0)\n",
+    "        B0_bbr = \"{}/{}_B0.nii.gz\".format(outdir, str(B0))\n",
+    "        #save the B0th dimension, a 1 dimensional ROI at B0, the voxel corresponding to the B0th\n",
+    "        B0_dwi = dwi_file_loaded_np[:,:,:,B0]\n",
+    "        #convert back to nifti image using the affine of original image\n",
+    "        B0_nifti = nib.Nifti1Image(B0_dwi, dwi_file_loaded.affine)\n",
+    "        #save in path\n",
+    "        nib.save(B0_nifti, B0_bbr)\n",
+    "        #save for mean image later\n",
+    "        B0s_bbr.append(B0_bbr)\n",
+    "#     for B0 in B0s:\n",
+    "#         print(B0)\n",
+    "#         B0_bbr = \"{}/{}_B0.nii.gz\".format(outdir, str(B0))\n",
+    "#         cmd = \"fslroi \" + dwi_file + \" \" + B0_bbr + \" \" + str(B0) + \" 1\"\n",
+    "#         cmds.append(cmd)\n",
+    "    \n",
+    "\n",
+    "#     for cmd in cmds:\n",
+    "#         print(cmd)\n",
+    "#         os.system(cmd)\n",
+    "\n",
+    "    # Get mean B0\n",
+    "    B0s_bbr_imgs = []\n",
+    "    for B0 in B0s_bbr:\n",
+    "        B0s_bbr_imgs.append(nib.load(B0))\n",
+    "\n",
+    "    mean_B0 = mean_img(B0s_bbr_imgs)\n",
+    "    nib.save(mean_B0, nodif_B0)\n",
+    "    \n",
+    "#old func\n",
+    "# #Get mean B0 brain mask\n",
+    "#     cmd = \"bet \" + nodif_B0 + \" \" + nodif_B0_bet + \" -m -f 0.2\"\n",
+    "#     os.system(cmd)\n",
+    "    \n",
+    "    ### using median_ostu \n",
+    "    \n",
+    "    #extract data from file\n",
+    "    nodif_B0_data = nib.load(nodif_B0)\n",
+    "    nodif_B0_array = nodif_B0_data.get_fdata()\n",
+    "    \n",
+    "    #pass np array into dipy\n",
+    "    nodif_B0_dipy = dipy.segment.mask.median_otsu(nodif_B0_array)\n",
+    "    \n",
+    "    #extract bet and bet_mask\n",
+    "    nodif_B0_dipy_bet = nodif_B0_dipy[0]\n",
+    "    #encode True False as float 0,1\n",
+    "    nodif_B0_dipy_bet_mask = nodif_B0_dipy[1].astype(float)\n",
+    "    \n",
+    "    #apply affine to convert back into nifti image\n",
+    "    nodif_B0_dipy_bet_nifti = nib.Nifti1Image(nodif_B0_dipy_bet, nodif_B0_data.affine)\n",
+    "    nodif_B0_dipy_bet_mask_nifti = nib.Nifti1Image(nodif_B0_dipy_bet_mask, nodif_B0_data.affine)\n",
+    "    \n",
+    "    #store bet and bet_mask at designated locations\n",
+    "    nib.save(nodif_B0_dipy_bet_nifti, nodif_B0_bet)\n",
+    "    nib.save(nodif_B0_dipy_bet_mask_nifti, nodif_B0_mask)\n",
+    "    \n",
+    "    return gtab, nodif_B0, nodif_B0_mask\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Other Useful Functions for processing Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def dice_score(A,B):\n",
+    "    \"\"\"\n",
+    "    A: Baseline numpy array to be compared\n",
+    "    B: Alternative numpy arrray to be compared\n",
+    "    \n",
+    "    out: dice score\n",
+    "    \"\"\"\n",
+    "    #smooth\n",
+    "    smooth = 1.0\n",
+    "    #convert to torch tensor and flatten\n",
+    "    A_flat = torch.from_numpy(A).contiguous().view(-1)\n",
+    "    B_flat = torch.from_numpy(B).contiguous().view(-1)\n",
+    "    \n",
+    "    #calc dice components\n",
+    "    intersection = (A_flat * B_flat).sum()\n",
+    "    A_sum = torch.sum(A_flat*A_flat)\n",
+    "    B_sum = torch.sum(B_flat*B_flat)\n",
+    "    \n",
+    "    #calc dice\n",
+    "    dice = (2. * intersection + smooth)/(A_sum + B_sum + smooth)\n",
+    "    \n",
+    "    return dice\n",
+    "\n",
+    "def extract_data(outdir):\n",
+    "    nodif_B0 = \"{}/nodif_B0.nii.gz\".format(outdir)\n",
+    "    nodif_B0_bet = \"{}/nodif_B0_bet.nii.gz\".format(outdir)\n",
+    "    nodif_B0_mask = \"{}/nodif_B0_bet_mask.nii.gz\".format(outdir)\n",
+    "    \n",
+    "    nodif_B0_data = nib.load(nodif_B0).get_fdata()\n",
+    "    nodif_B0_bet_data = nib.load(nodif_B0_bet).get_fdata()\n",
+    "    nodif_B0_mask_data = nib.load(nodif_B0_mask).get_fdata()\n",
+    "    return [nodif_B0_data,nodif_B0_bet_data,nodif_B0_mask_data]\n",
+    "\n",
+    "def graph_data_roi(og_data,roi_data):\n",
+    "    %matplotlib inline \n",
+    "    plt.figure()\n",
+    "\n",
+    "    f, ax = plt.subplots(1,2)\n",
+    "\n",
+    "    ax[0].imshow(og_data[0][46]) \n",
+    "    ax[0].set_title('Example Slice for FSL ROI')\n",
+    "    ax[1].imshow(roi_data[0][46])\n",
+    "    ax[1].set_title('Example Slice for PYTHON ROI')\n",
+    "\n",
+    "    f.subplots_adjust(wspace = 2, hspace = 0.5)\n",
+    "\n",
+    "    plt.show()\n",
+    "\n",
+    "def graph_data_bet(og_data,bet_data):\n",
+    "    %matplotlib inline \n",
+    "    plt.figure()\n",
+    "\n",
+    "    f, ax = plt.subplots(2,2)\n",
+    "\n",
+    "    ax[0,0].imshow(og_data[1][46]) \n",
+    "    ax[0,0].set_title('Example Slice for FSL BET')\n",
+    "    ax[0,1].imshow(bet_data[1][46])\n",
+    "    ax[0,1].set_title('Example Slice for DIPY MEDIAN_OSTU')\n",
+    "    ax[1,0].imshow(og_data[2][46]) \n",
+    "    ax[1,0].set_title('Example Mask_Slice for FSL BET')\n",
+    "    ax[1,1].imshow(bet_data[2][46])\n",
+    "    ax[1,1].set_title('Example Mask_Slice for DIPY MEDIAN_OSTU')\n",
+    "\n",
+    "    f.subplots_adjust(wspace = 2, hspace = 0.5)\n",
+    "\n",
+    "    plt.show()\n",
+    "    \n",
+    "def graph_data_both(og_data,both_data):\n",
+    "    %matplotlib inline \n",
+    "    plt.figure()\n",
+    "\n",
+    "    f, ax = plt.subplots(3,2)\n",
+    "\n",
+    "    ax[0,0].imshow(og_data[0][46]) \n",
+    "    ax[0,0].set_title('Example Slice for FSL ROI')\n",
+    "    ax[0,1].imshow(both_data[0][46])\n",
+    "    ax[0,1].set_title('Example Slice for Python ROI')\n",
+    "    \n",
+    "    ax[1,0].imshow(og_data[1][46])\n",
+    "    ax[1,0].set_title('Example Slice for FSL BET')\n",
+    "    ax[1,1].imshow(both_data[1][46])\n",
+    "    ax[1,1].set_title('Example Slice for DIPY MEDIAN_OSTU')\n",
+    "    \n",
+    "    ax[2,0].imshow(og_data[2][46])     \n",
+    "    ax[2,0].set_title('Example Mask_Slice for FSL BET')\n",
+    "    ax[2,1].imshow(both_data[2][46])\n",
+    "    ax[2,1].set_title('Example Mask_Slice for DIPY MEDIAN_OSTU')\n",
+    "\n",
+    "    f.subplots_adjust(wspace = 2, hspace = 1)\n",
+    "\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Test Dice Score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(141, 141, 68)\n",
+      "tensor(1., dtype=torch.float64)\n",
+      "tensor(1.3165e-11, dtype=torch.float64)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#test dice \n",
+    "nodif_B0 = '/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc/nodif_B0.nii.gz'\n",
+    "#test what it outputs. \n",
+    "nodif_B0_data = nib.load(nodif_B0)\n",
+    "nodif_B0_array = nodif_B0_data.get_fdata()\n",
+    "\n",
+    "nodif_zeros = np.zeros(nodif_B0_array.shape)\n",
+    "print(nodif_zeros.shape)\n",
+    "\n",
+    "print(dice_score(nodif_B0_array,nodif_B0_array))\n",
+    "print(dice_score(nodif_B0_array,nodif_zeros))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run Tests for Replacement Functions: Calculate Dice and Graph Sample Outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('sub_0025864_', '/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc/')]\n",
+      "['/Users/wilsontang/Desktop/make_gtab_and_bmask_temp/sub_0025864_']\n"
+     ]
+    }
+   ],
+   "source": [
+    "### define data directories\n",
+    "base_path = '/Users/wilsontang/Desktop/ndmg_outputs'\n",
+    "file_folder = '/dwi/preproc/'\n",
+    "\n",
+    "# sub_0025841_ses_1 = base_path + 'sub_0025841_ses_1' + file_folder\n",
+    "# sub_0025841_ses_2 = base_path + 'sub_0025841_ses_2' + file_folder\n",
+    "# sub_0025842_ses_1 = base_path + 'sub_0025842_ses_1' + file_folder\n",
+    "# sub_0025842_ses_2 = base_path + 'sub_0025842_ses_2' + file_folder\n",
+    "# sub_0025843_ses_1 = base_path + 'sub_0025843_ses_1' + file_folder\n",
+    "# sub_0025843_ses_2 = base_path + 'sub_0025843_ses_2' + file_folder\n",
+    "# sub_0025844_ses_1 = base_path + 'sub_0025844_ses_1' + file_folder\n",
+    "# sub_0025844_ses_2 = base_path + 'sub_0025844_ses_2' + file_folder\n",
+    "# sub_0025845_ses_1 = base_path + 'sub_0025845_ses_1' + file_folder\n",
+    "# sub_0025845_ses_2 = base_path + 'sub_0025841_ses_2' + file_folder\n",
+    "\n",
+    "#BNU1 enabled for now\n",
+    "sub_0025864_ = base_path + '/sub_0025864_' + file_folder\n",
+    "\n",
+    "#base\n",
+    "out_dir_base = '/Users/wilsontang/Desktop/make_gtab_and_bmask_temp/'\n",
+    "\n",
+    "data_dir = [('sub_0025864_',sub_0025864_)]\n",
+    "out_dir = [out_dir_base + 'sub_0025864_']\n",
+    "print(data_dir)\n",
+    "print(out_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//bval.bval\n",
+      "/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//bvec.bvec\n",
+      "B0's found at: [0]\n",
+      "B-values shape (31,)\n",
+      "         min 0.000000 \n",
+      "         max 1000.000000 \n",
+      "B-vectors shape (31, 3)\n",
+      "         min -0.978756 \n",
+      "         max 0.979329 \n",
+      "None\n",
+      "Extracting B0's...\n",
+      "0\n",
+      "fslroi /Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//eddy_corrected_data_reor_RAS_res.nii.gz /Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//0_B0.nii.gz 0 1\n",
+      "/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//bval.bval\n",
+      "/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//bvec.bvec\n",
+      "B0's found at: [0]\n",
+      "B-values shape (31,)\n",
+      "         min 0.000000 \n",
+      "         max 1000.000000 \n",
+      "B-vectors shape (31, 3)\n",
+      "         min -0.978756 \n",
+      "         max 0.979329 \n",
+      "None\n",
+      "Extracting B0's...\n",
+      "0\n",
+      "/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//bval.bval\n",
+      "/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//bvec.bvec\n",
+      "B0's found at: [0]\n",
+      "B-values shape (31,)\n",
+      "         min 0.000000 \n",
+      "         max 1000.000000 \n",
+      "B-vectors shape (31, 3)\n",
+      "         min -0.978756 \n",
+      "         max 0.979329 \n",
+      "None\n",
+      "Extracting B0's...\n",
+      "0\n",
+      "fslroi /Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//eddy_corrected_data_reor_RAS_res.nii.gz /Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//0_B0.nii.gz 0 1\n",
+      "/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//bval.bval\n",
+      "/Users/wilsontang/Desktop/ndmg_outputs/sub_0025864_/dwi/preproc//bvec.bvec\n",
+      "B0's found at: [0]\n",
+      "B-values shape (31,)\n",
+      "         min 0.000000 \n",
+      "         max 1000.000000 \n",
+      "B-vectors shape (31, 3)\n",
+      "         min -0.978756 \n",
+      "         max 0.979329 \n",
+      "None\n",
+      "Extracting B0's...\n",
+      "0\n",
+      "Dice Comparisons for: sub_0025864_\n",
+      "Original ROI vs. ROI Replacement: Dice Score per File and Sample Visualizations\n",
+      "[1] nodif_B0: 1.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x288 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original BET vs. Median OSTU: Dice Score per File and Sample Visualizations\n",
+      "[1] nodif_B0_bet: 0.9497404057263638 [2] nodif_B0_bmask: 0.8910177947162953\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x288 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original ROI,BET vs. ROI Replacement, Median OSTU: Dice Score per File and Sample Visualizations\n",
+      "[1] nodif_B0: 1.0 [2] nodif_B0_bet: 0.9497404057263638 [3] nodif_B0_bmask: 0.8910177947162953\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x288 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "#run across multiple file directories, \n",
+    "for i in range(len(data_dir)):\n",
+    "    #define correct input data path\n",
+    "    in_dir = data_dir[i][1]\n",
+    "    fbval_in_path = \"{}/bval.bval\".format(in_dir)\n",
+    "    fbvec_in_path = \"{}/bvec.bvec\".format(in_dir)\n",
+    "    dwi_prep_in_path = \"{}/eddy_corrected_data_reor_RAS_res.nii.gz\".format(in_dir)\n",
+    "    \n",
+    "#     #create 4 outdirs to store our experiment results\n",
+    "#     outdir = [out_dir[i] + '/og', out_dir[i] + '/roi', out_dir[i] + '/bet', out_dir[i] + '/both']\n",
+    "    \n",
+    "    #run each version, locally store variables, rewrite the in_dir files corresponding to outputs, inputs to each will remain the same\n",
+    "    #original\n",
+    "    [gtab_og, nodif_B0_out_temp_path_og, nodif_B0_mask_out_temp_path_og] = gen_utils.make_gtab_and_bmask(fbval_in_path, fbvec_in_path, dwi_prep_in_path, in_dir)\n",
+    "    og_data = extract_data(in_dir)\n",
+    "    #replace roi\n",
+    "    [gtab_roi, nodif_B0_out_temp_path_roi, nodif_B0_mask_out_temp_path_roi] = replace_roi_make_gtab_and_bmask(fbval_in_path, fbvec_in_path, dwi_prep_in_path, in_dir)\n",
+    "    roi_data = extract_data(in_dir)\n",
+    "    #replace bet\n",
+    "    [gtab_bet, nodif_B0_out_temp_path_bet, nodif_B0_mask_out_temp_path_bet] = replace_bet_make_gtab_and_bmask(fbval_in_path, fbvec_in_path, dwi_prep_in_path, in_dir)\n",
+    "    bet_data = extract_data(in_dir)\n",
+    "    #replace both\n",
+    "    [gtab_both, nodif_B0_out_temp_path_both, nodif_B0_mask_out_temp_path_both] = replace_both_make_gtab_and_bmask(fbval_in_path, fbvec_in_path, dwi_prep_in_path, in_dir)\n",
+    "    both_data = extract_data(in_dir)\n",
+    "    \n",
+    "    #alternatively, make 4 separate folders with the data, then pass each in so the results are always saved\n",
+    "    \n",
+    "    #compare with dice: nodif_B0, nodif_B0_bet, nodif_B0_bet_mask\n",
+    "    print('Dice Comparisons for: ' + data_dir[i][0])\n",
+    "    print('Original ROI vs. ROI Replacement: Dice Score per File and Sample Visualizations')\n",
+    "    print('[1] nodif_B0: '+ str( dice_score(og_data[0],roi_data[0]).item()) ) \n",
+    "    graph_data_roi(og_data,roi_data)\n",
+    "    print('Original BET vs. Median OSTU: Dice Score per File and Sample Visualizations')\n",
+    "    print('[1] nodif_B0_bet: ' + str(dice_score(og_data[1],bet_data[1]).item()) + ' [2] nodif_B0_bmask: ' + str(dice_score(og_data[2],bet_data[2]).item()) )\n",
+    "    graph_data_bet(og_data,bet_data)\n",
+    "    print('Original ROI,BET vs. ROI Replacement, Median OSTU: Dice Score per File and Sample Visualizations')\n",
+    "    print('[1] nodif_B0: '+ str(dice_score(og_data[0],both_data[0]).item()) + ' [2] nodif_B0_bet: ' + str(dice_score(og_data[1],both_data[1]).item()) + ' [3] nodif_B0_bmask: ' + str(dice_score(og_data[2],both_data[2]).item()))\n",
+    "    graph_data_both(og_data,both_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original ROI,BET vs. ROI Replacement, Median OSTU: Dice Score per File and Sample Visualizations\n",
+      "[1] nodif_B0: 1.0 [2] nodif_B0_bet: 0.9497404057263638 [3] nodif_B0_bmask: 0.8910177947162953\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x288 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "print('Original ROI,BET vs. ROI Replacement, Median OSTU: Dice Score per File and Sample Visualizations')\n",
+    "print('[1] nodif_B0: '+ str(dice_score(og_data[0],both_data[0]).item()) + ' [2] nodif_B0_bet: ' + str(dice_score(og_data[1],both_data[1]).item()) + ' [3] nodif_B0_bmask: ' + str(dice_score(og_data[2],both_data[2]).item()))\n",
+    "graph_data_both(og_data,both_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tests/test_data/temp_outputs/make_gtab_and_bmask/nodif_B0.nii.gz b/tests/test_data/temp_outputs/make_gtab_and_bmask/nodif_B0.nii.gz
index 81557eb08..a88df2b6f 100644
--- a/tests/test_data/temp_outputs/make_gtab_and_bmask/nodif_B0.nii.gz
+++ b/tests/test_data/temp_outputs/make_gtab_and_bmask/nodif_B0.nii.gz
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6154cf1e9aeaf9081ca80b9f0c2ffc56e0470dfc008e3c2db6cfb76ef1f24c4b
-size 10125144
+oid sha256:4a7c10a59e9cf1ab00a98edb9773f104b544c1c063939b8215adf29f60894abf
+size 4001000