rpipe 0.0.1

data/lib/default_methods/default_stats.rb

@@ -0,0 +1,94 @@
+module DefaultStats
+	
+	# runs the complete set of tasks using data in a subject's "proc" directory and a preconfigured template spm job.
+	def run_first_level_stats
+		flash "Highway to the dangerzone..."
+		setup_directory(@statsdir, "STATS")
+		
+		Dir.chdir(@statsdir) do
+			link_files_from_proc_directory
+			link_onsets_files
+			customize_template_job
+			run_stats_spm_job
+		end
+		
+	end
+	
+	alias_method :perform, :run_first_level_stats
+	
+	# Links all the files necessary from the "proc" directory. Links written to current working directory.
+	def link_files_from_proc_directory(images_wildcard = File.join(@procdir, "swq*.nii"), motion_regressors_wildcard = File.join(@procdir, "md_rp*.txt"))
+		puts Dir.glob(images_wildcard), @statsdir
+		raise IOError, "No images to link with #{images_wildcard}" if Dir.glob(images_wildcard).empty?
+		system("ln -s #{images_wildcard} #{@statsdir}")
+
+		raise IOError, "No motion_regressors to link with #{motion_regressors_wildcard}" if Dir.glob(motion_regressors_wildcard).empty?
+		system("ln -s #{motion_regressors_wildcard} #{@statsdir}")
+	end
+	
+	# Links to a preconfigured onsets file, a matlab file that contains three cell arrays: names, onsets, durations.
+	# This file is used by SPM to configure the conditions of the function task and the onset times to use in the model.
+	# Link is written to current working directory.
+	def link_onsets_files
+		@onsetsfiles.each do |ofile|
+			# Check if File Path is Absolute.  If not link from procdir/onsets
+			opath = Pathname.new(ofile).absolute? ? ofile : File.join(@procdir, 'onsets', ofile)
+			system("ln -s #{File.expand_path(opath)} #{Dir.pwd}")
+		end
+	end
+	
+	# Copies the template job to the current working directory, then customizes it by performing a set of recursive 
+	# string replacements specified in the template_spec.
+	def customize_template_job
+		# TODO
+	end
+	
+	# Finally runs the stats job and writes output to current working directory.
+	def run_stats_spm_job
+		# TODO
+	end
+	
+	# Create onsets files using logfile responses for given conditions.
+	#
+	# Responses is a hash containing a directory and filenames of the .txt
+	# button-press response logfiles formatted by Presentation's SDF.
+	#
+	# responses = { 'directory' => '/path/to/files', 'logfiles' => ['subid_taskB.txt', 'subid_taskA.txt']}
+	#
+	# Conditions is an array of vector labels to extract from the .txt file
+	# Each label may be either an individual condition or a hash of multiple 
+	# conditions, with the combined label as the key and the separate labels as
+	# values.
+	#
+	# conditions = [:new, :old, {:misses => [:new_misses, :old_misses]} ]
+	def create_onsets_files(responses, conditions)
+	  onsets_csv_files = []
+	  onsets_mat_files = []
+	  wd = Dir.pwd
+	  matching_directories = Dir.glob(responses['directory'])
+	  raise IOError, "Response directory #{responses['directory']} doesn't exist." unless File.directory?(responses['directory'])
+	  raise IOError, "Only one response directory currently accepted (matched directories: #{matching_directories.join(', ')})" unless matching_directories.length == 1
+	  Dir.chdir matching_directories.first  do
+	    responses['logfiles'].each do |logfile|
+  	    # Either Strip off the prefix directly without changing the name...
+        #   prefix = File.basename(logfile, '.txt')
+        # Or create a new name based on standard logfile naming scheme:
+        # mrt00000_abc_021110_faces3_recognitionA.txt
+        prefix = File.basename(logfile, '.txt').split("_").values_at(0,3,4).join("_")
+  	    log = Logfile.new(logfile, *conditions)
+  	    
+        # puts log.to_csv
+  	    onsets_csv_files << log.write_csv(prefix + '.csv')
+  	    onsets_mat_files << log.write_mat(prefix)
+      end
+      
+      [onsets_csv_files, onsets_mat_files].flatten.each do |response_file|
+	      FileUtils.move response_file, wd
+      end
+    end
+    
+    return onsets_mat_files
+  end
+  
+	
+end

data/lib/default_methods/recon/physionoise_helper.rb

@@ -0,0 +1,69 @@
+module DefaultRecon	
+	# Create Physionoise Regressors for Inclusion in GLM
+	def create_physiosnoise_regressors(scan_spec)
+    runs = build_physionoise_run_spec(scan_spec)
+    Physionoise.run_physionoise_on(runs, ["--saveFiles"])
+  end
+  
+  # Generate a Physionoise Spec
+  def generate_physiospec
+	  physiospec = Physiospec.new(@rawdir, File.join(@rawdir, '..', 'cardiac'))
+	  physiospec.epis_and_associated_phys_files
+  end
+  
+  # Build a Run Spec from a Scan Spec
+  # This should be moved to the generators and shouldn't be used here.
+  def build_physionoise_run_spec(rpipe_scan_spec)
+    run = rpipe_scan_spec['physio_files'].dup
+    flash "Physionoise Regressors: #{run[:phys_directory]}"
+    run[:bold_reps] = rpipe_scan_spec['bold_reps']
+    run[:rep_time] = rpipe_scan_spec['rep_time']
+    unless Pathname.new(run[:phys_directory]).absolute?
+      run[:phys_directory] = File.join(@rawdir, run[:phys_directory])
+    end
+    run[:run_directory] = @rawdir
+    runs = [run]
+  end
+	
+	# Runs 3dRetroicor for a scan.
+	# Returns the output filename if successful or raises an error if there was an error.
+	def run_retroicor(physio_files, file)
+	  icor_cmd, outfile = build_retroicor_cmd(physio_files, file)
+	  flash "3dRetroicor: #{file} \n #{icor_cmd}"
+	  if run(icor_cmd)
+	    return outfile
+    else
+      raise ScriptError, "Problem running #{icor_cmd}"
+    end
+  end
+	
+	# Builds a properly formed 3dRetroicor command and returns the command and 
+	# output filename.
+	#
+	# Input a physio_files hash with keys:
+	#   :respiration_signal: RESPData_epiRT_0303201014_46_27_463
+  #   :respiration_trigger: RESPTrig_epiRT_0303201014_46_27_463
+  #   :phys_directory: cardiac/
+  #   :cardiac_signal: PPGData_epiRT_0303201014_46_27_463
+  #   :cardiac_trigger: PPGTrig_epiRT_0303201014_46_27_463
+	def build_retroicor_cmd(physio_files, file)
+    [:cardiac_signal, :respiration_signal].collect {|req| raise ScriptError, "Missing physio config: #{req}" unless physio_files.include?(req)}
+    
+    prefix = 'p'
+    unless Pathname.new(physio_files[:cardiac_signal]).absolute?
+      cardiac_signal = File.join(@rawdir, physio_files[:phys_directory], physio_files[:cardiac_signal])
+    end
+    
+    unless Pathname.new(physio_files[:respiration_signal]).absolute?
+      respiration_signal = File.join(@rawdir, physio_files[:phys_directory], physio_files[:respiration_signal])
+    end
+    
+    outfile = prefix + file
+
+    icor_format = "3dretroicor -prefix %s -card %s -resp %s %s"
+    icor_options = [outfile, cardiac_signal, respiration_signal, file]
+    icor_cmd = icor_format % icor_options
+    return icor_cmd, outfile
+  end
+  
+end

data/lib/default_methods/recon/raw_sequence.rb

@@ -0,0 +1,109 @@
+module DefaultRecon
+  # An abstract class for Raw Image Sequences
+  # The Recon job will calls prepare on Raw Sequence Instances to process 
+  # them from their raw state (dicoms or pfiles) to Nifti files suitable for
+  # processing.
+  class RawSequence
+    def initialize(scan_spec, rawdir)
+      @scan_spec = scan_spec
+      @rawdir = rawdir
+    end
+  end
+
+  # Manage a folder of Raw Dicoms for Nifti file conversion
+  class DicomRawSequence < RawSequence
+    # Locally copy and unzip a folder of Raw Dicoms and call convert_sequence on them
+    def prepare_and_convert_sequence(outfile)
+      scandir = File.join(@rawdir, @scan_spec['dir'])
+      $Log.info "Dicom Reconstruction: #{scandir}"
+      Pathname.new(scandir).all_dicoms do |dicoms|
+        convert_sequence(dicoms, outfile)
+      end
+    end
+      
+    alias_method :prepare, :prepare_and_convert_sequence
+  
+    private
+  
+    # Convert a folder of unzipped Dicom files to outfile
+    def convert_sequence(dicoms, outfile)
+      local_scandir = File.dirname(dicoms.first)
+      second_file = Dir.glob( File.join(local_scandir, "*0002*") )
+      wildcard = File.join(local_scandir, "*.[0-9]*")
+    
+      recon_cmd_format = 'to3d -skip_outliers %s -prefix tmp.nii "%s"'
+
+      timing_opts = timing_options(@scan_spec, second_file)
+
+      unless run(recon_cmd_format % [timing_opts, wildcard])
+        raise(IOError,"Failed to reconstruct scan: #{scandir}")
+      end
+    end
+  
+    # Determines the proper timing options to pass to to3d for functional scans.
+    # Must pass a static path to the second file in the series to determine zt
+    # versus tz ordering. Assumes 2sec TR's. Returns the options as a string 
+    # that may be empty if the scan is an anatomical.
+    def timing_options(scan_spec, second_file)
+      return "" if scan_spec['type'] == "anat"
+      instance_offset = scan_spec['z_slices'] + 1
+      if system("dicom_hdr #{second_file} | grep .*REL.Instance.*#{instance_offset}")
+        return "-epan -time:tz #{scan_spec['bold_reps']} #{scan_spec['z_slices']} 2000 alt+z"
+      else
+        return "-epan -time:zt #{scan_spec['z_slices']} #{scan_spec['bold_reps']} 2000 alt+z"
+      end
+    end
+  end
+  
+  # Reconstucts a PFile from Raw to Nifti File
+  class PfileRawSequence < RawSequence
+    # Create a local unzipped copy of the Pfile and prepare Scanner Reference Data for reconstruction
+    def initialize(scan_spec, rawdir)
+      super(scan_spec, rawdir)
+      
+      base_pfile_path = File.join(@rawdir, @scan_spec['pfile'])
+      pfile_path = File.exist?(base_pfile_path) ? base_pfile_path : base_pfile_path + '.bz2'
+  
+      raise IOError, "#{pfile_path} does not exist." unless File.exist?(pfile_path)
+  
+      flash "Pfile Reconstruction: #{pfile_path}"
+      @pfile_data = Pathname.new(pfile_path).local_copy
+      
+      @refdat_file = @scan_spec['refdat_stem'] ||= search_for_refdat_file
+      setup_refdat(@refdat_file)
+    end
+  
+    # Reconstructs a single pfile using epirecon
+    # Outfile may include a '.nii' extension - a nifti file will be constructed
+    # directly in this case.
+    def reconstruct_sequence(outfile)
+      volumes_to_skip = @scan_spec['volumes_to_skip'] ||= 3
+      epirecon_cmd_format = "epirecon_ex -f %s -NAME %s -skip %d -scltype=0"
+      epirecon_cmd_options = [@pfile_data, outfile, volumes_to_skip]
+      epirecon_cmd = epirecon_cmd_format % epirecon_cmd_options
+      raise ScriptError, "Problem running #{epirecon_cmd}" unless run(epirecon_cmd)
+    end
+    
+    alias_method :prepare, :reconstruct_sequence
+    
+    private
+  
+    # Find an appropriate ref.dat file if not provided in the scan spec.
+    def search_for_refdat_file
+      Dir.new(@rawdir).each do |file|
+        return file if file =~ /ref.dat/
+      end
+      raise ScriptError, "No candidate ref.dat file found in #{@rawdir}"
+    end
+  
+    # Create a new unzipped local copy of the ref.dat file and link it into 
+    # pwd for reconstruction.
+    def setup_refdat(refdat_stem)
+      base_refdat_path = File.join(@rawdir, refdat_stem)
+      refdat_path = File.exist?(base_refdat_path) ? base_refdat_path : base_refdat_path + ".bz2"
+      raise IOError, "#{refdat_path} does not exist." unless File.exist?(refdat_path)
+      local_refdat_file = Pathname.new(refdat_path).local_copy
+      FileUtils.ln_s(local_refdat_file, Dir.pwd, :force => true)
+    end    
+   end
+end

data/lib/generators/job_generator.rb

@@ -0,0 +1,36 @@
+########################################################################################################################
+# A class for parsing a data directory and creating Job Specs
+class JobGenerator
+  # Configuration details are put in a spec hash and used to drive processing.
+  attr_reader :spec
+  # The spec hash of a previous step (i.e. the recon hash to build a preprocessing hash on.)
+  attr_reader :previous_step
+  
+  # Intialize spec and previous step and set job defaults.
+  def initialize(config = {})
+    @spec = {}
+    config_defaults = {}
+    @config = config_defaults.merge(config)
+    
+    @previous_step = @config['previous_step']
+    @spec['method'] = @config['method'] if @config['method']
+  end
+  
+  def config_requires(*args)
+    missing_args = [*args.collect { |arg| arg unless @config.has_key?(arg) }].flatten.compact
+    unless missing_args.empty?
+      raise DriverConfigError, "Missing Configuration for: #{missing_args.join(', ')}"
+    end      
+  end
+  
+  def spec_validates(*args)
+    invalid_args = [*args.collect{ |arg| arg if eval("@spec['#{arg}'].nil?")  }].flatten.compact
+    unless invalid_args.empty?
+      raise DriverConfigError, "Job could not create: #{invalid_args.join(', ')}"
+    end
+  end
+  
+end
+
+# Raised when a JobGenerator class is missing required information.
+class DriverConfigError < ScriptError; end

data/lib/generators/preproc_job_generator.rb

@@ -0,0 +1,31 @@
+require 'generators/job_generator'
+
+########################################################################################################################
+# A class for parsing a data directory and creating a default Preprocessing Job
+# Intialize a PreprocJobGenerator with a config hash including the following optional keys:
+#
+# - scans : A hash of scans upon which to base preprocessing. 
+#           Used to extract the correct bold reps for SPM.
+#           See #ReconJobGenerator for options for the scans hash.
+# 
+
+class PreprocJobGenerator < JobGenerator
+  def initialize(config = {})
+    config_defaults = {}
+    super config_defaults.merge(config)
+    
+    @spec['step'] = 'preprocess'
+    
+    config_requires 'scans'
+  end
+  
+  # Build a job spec and return it.
+  def build
+    bold_reps = []
+    @spec['bold_reps'] = @config['scans'].collect do |scan| 
+      scan['bold_reps'] - scan['volumes_to_skip']
+    end
+    
+    return @spec
+  end
+end

data/lib/generators/recon_job_generator.rb

@@ -0,0 +1,76 @@
+gem 'activeresource', '<=2.3.8'
+$LOAD_PATH.unshift('~/projects/metamri/lib').unshift('~/code/metamri/lib')
+require 'metamri'
+require 'generators/job_generator'
+
+########################################################################################################################
+# A class for parsing a data directory and creating a default Reconstruction Job
+# Intialize the ReconJobGenerator with the following options in a config hash.
+# 
+# Required Options:
+# - rawdir : The directory containing EPI runs
+#
+# Raises an IOError if the Raw Directory cannot be read, and a 
+# DriverConfigError if the Raw Directory is not specified.
+
+class ReconJobGenerator < JobGenerator
+  def initialize(config)
+    # Add job-specific config defaults to config and initialize teh JobGenerator with them.
+    config_defaults = {}
+    config_defaults['epi_pattern'] = /fMRI/i
+    config_defaults['ignore_patterns'] = [/pcasl/i]
+    config_defaults['volumes_to_skip'] = 3
+    super config_defaults.merge(config)
+
+    @spec['step'] = 'reconstruct'
+
+    config_requires 'rawdir'
+    @rawdir = @config['rawdir']
+    raise IOError, "Can't find raw directory #{@rawdir}" unless File.readable?(@rawdir)
+  end
+  
+  def build
+    scans = Array.new
+    
+    visit = VisitRawDataDirectory.new(@rawdir)
+    # Scan the datasets, ignoring unwanted (very large unused) directories.
+    visit.scan(:ignore_patterns => [@config['ignore_patterns']].flatten)
+    
+    visit.datasets.each do |dataset|
+      # Only build hashes for EPI datasets
+      next unless dataset.series_description =~ @config['epi_pattern']
+      
+      scans << build_scan_hash(dataset)
+    end
+    
+    @spec['scans'] = scans
+    
+    return @spec
+  end
+  
+  # Returns a hash describing how to reconstruct the dataset.
+  def build_scan_hash(dataset)
+    scan = {}
+    raw_image_file    = dataset.raw_image_files.first
+    # phys = Physionoise.new(@rawdir, File.join(@rawdir, '..', 'cardiac' ))
+    
+    scan['dir']             = dataset.relative_dataset_path
+    scan['type']            = 'func'
+    scan['z_slices']        = raw_image_file.num_slices
+    scan['bold_reps']       = raw_image_file.bold_reps
+    scan['volumes_to_skip'] = @config['volumes_to_skip']
+    scan['rep_time']        = raw_image_file.rep_time.in_seconds
+    scan['label']           = dataset.series_description.escape_filename
+    # scan['task']            = '?'
+    # scan['physio_files']    = "#TODO"
+    
+    return scan
+  end
+end
+
+# Convert Milliseconds to Seconds for TRs
+class Float
+  def in_seconds
+    self / 1000.0
+  end
+end

data/lib/generators/stats_job_generator.rb

@@ -0,0 +1,70 @@
+require 'generators/job_generator'
+require 'logfile'
+
+########################################################################################################################
+# A class for parsing a data directory and creating a default Stats Job
+# Intialize a StatsJobGenerator with a config hash including the following optional keys:
+#
+# - subid : SubjectID (i.e. 'mrt00015') 
+# - conditions : An array of condition names for analysis.
+# - scans : A hash containing scan information (labels, bold_reps, etc.)
+
+class StatsJobGenerator < JobGenerator
+  def initialize(config = {})
+    config_defaults = {}
+    config_defaults['epi_task_pattern'] = /Task/i
+    config_defaults['regressors_prefix'] = 'rp_a'
+    super config_defaults.merge(config)
+    
+    @spec['step'] = 'stats'
+
+    config_requires 'scans', 'subid', 'conditions', 'responses_dir'
+    
+    @scans = []
+    @config['scans'].each { |scan| @scans << scan if scan['label'] =~ @config['epi_task_pattern'] }
+    
+  end
+  
+  def build
+    @spec['bold_reps']        = bold_reps
+    @spec['responses']        = responses
+    @spec['conditions']       = @config['conditions']
+    @spec['regressorsfiles']  = regressorsfiles
+    return @spec 
+  end
+  
+  def bold_reps
+    return @bold_reps if @bold_reps
+    bold_reps = []
+    @scans.collect {|scan| scan['bold_reps'] - scan['volumes_to_skip']}
+  end
+  
+  # A getter/builder method for behavioural responses.
+  def responses
+    return @responses if @responses
+    @responses = {}
+    @responses['directory'] = @config['responses_dir']
+    @responses['logfiles'] = logfiles
+
+    return @responses
+  end
+  
+  def logfiles
+    return @logfiles if @logfiles
+    logfiles = Dir.glob(File.join(@responses['directory'], @config['subid'] + "*.txt"))
+    raise IOError, "No logfiles found in #{@responses['directory']} matching #{@config['subid']}" if logfiles.empty?
+    logfiles = logfiles.collect! {|file| Logfile.new(file)}.sort
+    @logfiles = logfiles.collect! {|file| File.basename(file.textfile) }
+  end
+  
+  def regressorsfiles
+    return @regressorsfiles if @regressorsfiles
+    regressorsfiles = []
+    @regressorsfiles = @scans.collect {|scan| "%s%s_%s.txt" % [ @config['regressors_prefix'], @config['subid'], scan['label'] ]}
+  end
+  
+  def valid?
+    spec_validates 'regressorsfiles', 'responses'
+  end
+  
+end

data/lib/generators/workflow_generator.rb

@@ -0,0 +1,128 @@
+require 'tmpdir'
+require 'pathname'
+
+require 'core_additions'
+require 'generators/recon_job_generator'
+require 'generators/preproc_job_generator'
+require 'generators/stats_job_generator'
+
+########################################################################################################################
+# A class for parsing a data directory and creating default Driver Configurations
+# Intialize a WorkflowGenerator with a Raw Directory containing Scans
+# and with the following optional keys in a config hash:
+#
+# Directory Options:
+#  - processing_dir : A directory common to  orig, proc and stats directories, if they are not explicitly specified..
+#  - origdir : A directory where dicoms will be converted to niftis and basic preprocessing occurs.
+#  - procdir : A directory for detailed preprocessing (normalization and smoothing)
+#  - statsdir : A directory where stats will be saved.  (This should be a final directory.)
+
+class WorkflowGenerator < JobGenerator
+  attr_reader :spec
+  
+  def initialize(rawdir, config = Hash.new)
+    config_defaults = {}
+    config_defaults['conditions'] = ['new_correct', 'new_incorrect', 'old_correct', 'old_incorrect']
+    config_defaults['processing_dir'] = Dir.mktmpdir
+    super config_defaults.merge(config)
+    
+    @rawdir = rawdir
+    @spec['rawdir'] = @rawdir
+    @spec['subid'] = parse_subid
+    @spec['study_procedure'] = @config['study_procedure'] ||= guess_study_procedure_from(@rawdir)
+
+    config_requires 'responses_dir'
+  end
+  
+  # Create and return a workflow spec to drive processing
+  def build    
+    configure_directories
+    
+    @spec['collision'] = 'destroy'
+    
+    
+    jobs = []
+    
+    # Recon
+    recon_options = {'rawdir' => @rawdir, 'epi_pattern' => /(Resting|Task)/i, }
+    config_step_method(recon_options, 'recon') if @config['custom_methods']
+    jobs << ReconJobGenerator.new(recon_options).build
+    
+    # Preproc
+    preproc_options = {'scans' => jobs.first['scans']}
+    config_step_method(preproc_options, 'preproc') if @config['custom_methods']
+    jobs << PreprocJobGenerator.new(preproc_options).build
+    
+    # Stats
+    stats_options = {
+      'scans' => jobs.first['scans'],
+      'conditions' => @config['conditions'],
+      'responses_dir' => @config['responses_dir'],
+      'subid' => @spec['subid']
+    }
+    config_step_method(stats_options, 'stats') if @config['custom_methods']
+    jobs << StatsJobGenerator.new(stats_options).build
+    
+    @spec['jobs'] = jobs
+    
+    return @spec
+  end
+  
+  # Guesses a Subject Id from @rawdir
+  # Takes the split basename of rawdir itself if rawdir includes subdir, or
+  # the basename of its parent.
+  def parse_subid
+    subject_path = File.basename(@rawdir) == 'dicoms' ? 
+      Pathname.new(File.join(@rawdir, '..')).realpath : Pathname.new(@rawdir).realpath
+    
+    subject_path.basename.to_s.split('_').first
+  end
+  
+  # Handle Directory Configuration and Defaults for orig, proc and stats dirs.
+  def configure_directories
+    processing_dir = @config['processing_dir']
+    @spec['origdir']  = @config['origdir']  || parse_directory_format(@config['directory_formats']['origdir'])  || File.join(processing_dir, @spec['subid'] + '_orig')
+    @spec['procdir']  = @config['procdir']  || parse_directory_format(@config['directory_formats']['procdir'])  || File.join(processing_dir, @spec['subid'] + '_proc')
+    @spec['statsdir'] = @config['statsdir'] || parse_directory_format(@config['directory_formats']['statsdir']) || File.join(processing_dir, @spec['subid'] + '_stats')
+  end
+  
+  # Replace a directory format string with respective values from the spec.
+  # For example, replace the string "/Data/<study_procedure>/<subid>/stats" from
+  # a workflow_driver['directory_formats']['statsdir'] with 
+  # "/Data/johnson.merit220.visit1/mrt00000/stats"
+  def parse_directory_format(fmt)
+    dir = fmt.dup
+    dir.scan(/<\w*>/).each do |replacement|
+      key = replacement.to_s.gsub(/(<|>)/, '')
+      dir.sub!(/<\w*>/, @spec[key])
+    end
+    return dir
+  end
+  
+  # Guess a StudyProcedure from the data's raw directory.
+  # A properly formed study procdure should be: <PI>.<Study>.<Description or Visit>
+  # Raises a ScriptError if it couldn't guess a reasonable procedure.
+  def guess_study_procedure_from(dir)
+    dirs = dir.split("/")
+    while dirs.empty? == false do
+      current_dir = dirs.pop
+      return current_dir if current_dir =~ /\w*\.\w*\.\w*/
+    end
+    raise ScriptError, "Could not guess study procedure from #{dir}"
+  end
+  
+  # Configure Custom Methods from the Workflow Driver
+  #
+  # Custom methods may be simply set to true for a given job or listed 
+  # explicitly.  If true, they will set the method to the a camelcased version
+  # of the study_procedure and step, i.e. JohnsonMerit220Visit1Stats
+  # If listed explicitly, it will set the step to the value listed.
+  def config_step_method(options, step)
+    if @config['custom_methods'][step].class == String
+      options['method'] = @config['custom_methods'][step]
+    elsif @config['custom_methods'][step] == true
+      options['method'] = [@config['study_procedure'], step.capitalize].join("_").dot_camelize
+    end
+  end
+    
+end

data/lib/global_additions.rb

@@ -0,0 +1,18 @@
+require 'popen4'
+
+# Global Method to Log and Run system commands.
+def run(command)
+  $CommandLog.info command
+  
+  status = POpen4::popen4(command) do |stdout, stderr|
+    puts stdout.read.strip
+    puts stderr.read.strip
+  end
+      
+  status && status.exitstatus == 0 ? true : false
+end
+
+# Global Method to display a message and the date/time to standard output.
+def flash(msg)
+	$Log.info msg
+end