Hi Julia,

what about creating multiple bedpost folders (with all the files) for 
every subject. The only difference between the folders is the 
nodif_brain_mask that shows different subregions of the brain mask in 
every folder.

It is not very memory or network efficient but very simple to implement.
Just run the normal bedpostx on every folder and then merge the results 
using fslmaths -max .

Best, Jan




On 08/27/2014 05:57 PM, Owen, Julia wrote:
> Ok, you have helped me solve the first problem of how to get the same
> merged files from running bedpostx (as one normally would) and running
> bedpostx_single_slice.sh on every slice in my code.
>
> Now, I'll tackle my original problem of how to get more parallelization.
>   I was thinking that I would divide each slice into four strips and
> then I can merge the outputs.  I know this is going to be a bit of a
> book-keeping pain, but It'll be obvious if I don't do it correctly.
>
> Thanks so much for all your help, I think I am set for now.
>
> Best, Julia
> ------------------------------------------------------------------------
> *From:* FSL - FMRIB's Software Library [[log in to unmask]] on behalf of
> Moises Hernandez [[log in to unmask]]
> *Sent:* Wednesday, August 27, 2014 2:33 AM
> *To:* [log in to unmask]
> *Subject:* Re: [FSL] Make bedpostx more parallel
>
> Hi Julia,
> yes, those are the default options for bedpostx_single_slice.sh.
>
> But if you take a look to this script (bedpostx_single_slice.sh), you
> can see that you will need these files:
>
> bedpostx_analysis_multishell/data_slice_$n
> bedpostx_analysis_multishell/nodif_brain_mask_slice_$n
>
> bedpostx_analysis_multishell/bvals
> bedpostx_analysis_multishell/bvecs
>
> Maybe in your case is better to avoid the call to
> bedpostx_single_slice.sh and call directly to xfibres (using the queue)
> using the same parameters, with:
>
> --data=X
> --mask=Y
> --logdir=Z
>
> X will be the part that you are going to process
> Y will be the mask of this part
> Z will be the output directory of this part
>
> The rest of parameters are common for all the parts (-b, -r ......).
> subjdir.bedpostX/log/log$slicezp  is the file for log output
>
> I am still not sure how are you going to merge all the output files.
> Probably this is going to be the most problematic thing.
> fslmerge only allows you to concatenate in a specific direction (x,y,z
> or time).
>
> Best,
> Moises.
>
> Best,
> Moises.
>
>
>
>
> On 26 August 2014 19:46, Owen, Julia <[log in to unmask]
> <mailto:[log in to unmask]>> wrote:
>
>     Hi Moises,
>
>     Thanks again for the very helpful email.  I have coded up everything
>     as you suggest only that I am still not certain how to call
>     bedpostx_single_slice.sh such that it is called exactly as when
>     executing bedpostx (with --model=2 for our multishell data).  I
>     looked at the bedpostx source code and I have to admit following
>     every line is giving me a bit of an issue.  But, I think I have
>     deciphered how to replicate the call in the following:
>
>     bedpostx_single_slice.sh bedpostx_analysis_multishell $n --nf=2
>     --fudge=1 --bi=1000 --nj=1250 --se=25 --model=2
>
>     where $n is the slice number.
>
>     Are there any other default inputs to bedpostx_single_slice.sh that
>     I have missed?
>
>     Best, Julia
>     ------------------------------------------------------------------------
>     *From:* FSL - FMRIB's Software Library [[log in to unmask]
>     <mailto:[log in to unmask]>] on behalf of Moises Hernandez
>     [[log in to unmask] <mailto:[log in to unmask]>]
>     *Sent:* Tuesday, August 26, 2014 9:23 AM
>
>     *To:* [log in to unmask] <mailto:[log in to unmask]>
>     *Subject:* Re: [FSL] Make bedpostx more parallel
>
>     Hi Julia,
>
>     yes, it is still valid, bedpostx is using it to run each slice.
>
>     Basically bedpostx script does these things:
>
>     1. Prepare the output directory
>     2. Submit pre-processing script (it divides the data into slices)
>     3. Submit several bedpostx_single_slice scripts (for each slice) to
>     run in parallel (each job will call xfibres)
>     4. Submit postprocesing script (it merges the output slices)
>
>     3 must wait for 2 to finish
>     4 must wait for 3 to finish
>
>     Maybe you are missing some parameters when you use
>     bedpostx_single_slice or you are using the incorrect mask slice.
>
>     What you can do is to check that the commands that bedpostx write in
>     the file subject.bedpostX/commands.txt are the same that you
>     are using to call bedpostx_single_slice.
>
>
>     Best,
>     Moises.
>
>
>
>     On 26 August 2014 16:59, Owen, Julia <[log in to unmask]
>     <mailto:[log in to unmask]>> wrote:
>
>         Thank you, Moises!
>
>         Great - that was my intuition for how to solve the problem.
>
>         A follow-up questions is: Is the function
>         "bedpostx_single_slice.sh" still valid?  After I sent my email
>         yesterday, I realized that the result from 1)
>         using bedpostx_single_slice.sh on every slice and 2) running
>         bedpostx (with the automatic submission to our SGE) yields very
>         different results (even after forcing bedpostx_single_slice.sh
>         to fit two fibers).  I have a feeling this function is perhaps
>         defunct.  If so, I can look at what bedpostx is doing, but I
>         originally thought bedpostx_single_slice.sh (or something like
>         it) was being called in parallel withink bedpostx.
>
>         Thanks again, Julia
>         ------------------------------------------------------------------------
>         *From:* FSL - FMRIB's Software Library [[log in to unmask]
>         <mailto:[log in to unmask]>] on behalf of Moises Hernandez
>         [[log in to unmask] <mailto:[log in to unmask]>]
>         *Sent:* Tuesday, August 26, 2014 2:47 AM
>         *To:* [log in to unmask] <mailto:[log in to unmask]>
>         *Subject:* Re: [FSL] Make bedpostx more parallel
>
>         Hi Julia,
>
>         what you could do is to use fslroi instead of fslslice to divide
>         your data in as many parts as you want. They can be smaller than
>         a slice. Then you can process these parts in parallel.
>
>         You have to code up the main script bedpostx (submit parts, not
>         slices), the preprocessing script bedpostx_preproc.sh (you do
>         not want to use fslslice), and the post processing script
>         (merging process).
>
>         If you want to create parts with a similar number of voxels you
>         can calculate how many Non-zero voxels there are in the mask
>         (fslstats mask -V).
>
>         Best,
>         Moises.
>
>
>         On 25 August 2014 17:59, Owen, Julia <[log in to unmask]
>         <mailto:[log in to unmask]>> wrote:
>
>             Hi,
>
>             I currently have bedpostx running parallel over slices.  I
>             don't use the automatic fsl_sub submission process, rather
>             I've coded up bedpostx_single_slice.sh to run in parallel on
>             our large institutional grid.  Each slice takes from 20mins
>             to 2.5 hrs.  The grid I am using has two queues, one for
>             jobs under 30 mins and one for jobs over 30 mins.  The
>             shorter queue is preferable, so I was wondering if there is
>             a way to break the jobs up into smaller jobs than just
>             slices so I can get all jobs under 30 mins.  Without fully
>             understanding what goes on the fitting process, I wanted to
>             see if the developers had any suggestions for how I can do
>             this.  I couldn't find a previous post on this, excuse me if
>             this is a duplicate.
>
>             Thanks in advance,
>
>             Julia
>
>
>
>