AFNI program: AlphaSim

++ AlphaSim: AFNI version=AFNI_2008_07_18_1710 (Jan 29 2009) [32-bit]
++ Authored by: B. Douglas Ward
This program performs alpha probability simulations.  

Usage: 
AlphaSim 
-nx n1        n1 = number of voxels along x-axis                      
-ny n2        n2 = number of voxels along y-axis                      
-nz n3        n3 = number of voxels along z-axis                      
-dx d1        d1 = voxel size (mm) along x-axis                       
-dy d2        d2 = voxel size (mm) along y-axis                       
-dz d3        d3 = voxel size (mm) along z-axis                       
-nxyz n1 n2 n3   = give all 3 grid dimensions at once                 
-dxyz d1 d2 d3   = give all 3 voxel sizes at once                     
[-mask mset]      Use the 0 sub-brick of dataset 'mset' as a mask     
                    to indicate which voxels to analyze (a sub-brick  
                    selector is allowed)  [default = use all voxels]  
                  Note:  The -mask command also REPLACES the          
                         -nx, -ny, -nz, -dx, -dy, and -dz commands,   
                         and takes the volume dimensions from 'mset'. 
[-fwhm s]     s  = Gaussian filter width (FWHM, in mm)                
[-fwhmx sx]   sx = Gaussian filter width, x-axis (FWHM)               
[-fwhmy sy]   sy = Gaussian filter width, y-axis (FWHM)               
[-fwhmz sz]   sz = Gaussian filter width, z-axis (FWHM)               
[-sigma s]    s  = Gaussian filter width (1 sigma, in mm)             
[-sigmax sx]  sx = Gaussian filter width, x-axis (1 sigma)            
[-sigmay sy]  sy = Gaussian filter width, y-axis (1 sigma)            
[-sigmaz sz]  sz = Gaussian filter width, z-axis (1 sigma)            

[-power]      perform statistical power calculations                  
[-ax n1]      n1 = extent of active region (in voxels) along x-axis   
[-ay n2]      n2 = extent of active region (in voxels) along y-axis   
[-az n3]      n3 = extent of active region (in voxels) along z-axis   
[-zsep z]     z = z-score separation between signal and noise         

[-rmm r]      r  = cluster connection radius (mm)                     
                   Default is nearest neighbor connection only.       
-pthr p       p  = individual voxel threshold probability             
-iter n       n  = number of Monte Carlo simulations                  
[-quiet]      suppress lengthy per-iteration screen output            
[-out file]   file = name of output file [default value = screen]     
[-max_clust_size size]  size = maximum allowed voxels in a cluster    
[-seed S]     S  = random number seed
                   default seed = 1234567
                   if seed=0, then program will randomize it
[-fast]       Use a faster random number generator:
                Can speed program up by about a factor of 2,
                but detailed results will differ slightly since
                a different sequence of random values will be used.

Unix environment variables you can use:
---------------------------------------
 Set AFNI_BLUR_FFT to YES to require blurring be done with FFTs
   (the oldest way, and slowest).
 Set AFNI_BLUR_FFT to NO and AFNI_BLUR_FIROLD to YES to require
   blurring to be done with the old (crude) FIR code (not advised).
 If neither of these are set, then blurring is done using the newer
   (more accurate) FIR code (recommended).
 Results will differ in detail depending on the blurring method
   used to generate the simulated noise fields.

SAMPLE OUTPUT:
--------------
 AlphaSim -nxyz 64 64 10 -dxyz 3 3 3 -iter 10000 -pthr 0.004 -fwhm 3 -quiet -fast

Cl Size     Frequency    CumuProp     p/Voxel   Max Freq       Alpha
      1       1316125    0.898079  0.00401170          0    1.000000
      2        126353    0.984298  0.00079851       1023    1.000000
      3         18814    0.997136  0.00018155       5577    0.897700
      4          3317    0.999400  0.00004375       2557    0.340000
      5           688    0.999869  0.00001136        653    0.084300
      6           150    0.999971  0.00000296        148    0.019000
      7            29    0.999991  0.00000076         29    0.004200
      8             8    0.999997  0.00000027          8    0.001300
      9             5    1.000000  0.00000011          5    0.000500

 That is, thresholded random noise alone (no signal) would produce a
 cluster of size 6 or larger 1.9% (Alpha) of the time, in a 64x64x64
 volume with cubical 3 mm voxels and a FHWM noise smoothness of 3 mm.

N.B.: If you run the exact command above, you will get slightly
 different results, due to variations in the random numbers generated
 in the simulations.