+ added settings in the form of a global and a run specific part
authorFabio <fabio@Calculon.(none)>
Tue, 9 Sep 2008 10:58:20 +0000 (12:58 +0200)
committerFabio <fabio@Calculon.(none)>
Tue, 9 Sep 2008 10:58:20 +0000 (12:58 +0200)
+ settings are stored as dict. entries

doc/qpalma.tex
dyn_prog/qpalma_dp.cpp
qpalma/gridtools.py
qpalma/set_param_palma.py
qpalma/utils.py [new file with mode: 0644]
scripts/Utils.py [deleted file]
scripts/grid_heuristic.py
scripts/qpalma_pipeline.py
setup.py

index 53ce4f2..24799dd 100644 (file)
@@ -44,9 +44,28 @@ The project results directory (\emph{result\_dir}) contains then the subdirector
 %
 %
 %
+\section{Installation}
+
+QPalma has the following requirements:
+\begin{itemize}
+\item Numpy
+\item In order to use QPalma on a cluster you need the pythongrid package which
+can be found under the following URL:
+\item For training you need either one of the following optimization toolkits:
+\begin{itemize}
+\item CPLEX
+\item CVXOPT
+\item MOSEK
+\end{itemize}
+\end{itemize}
+
+
+%
+%
+%
 \section{Pipeline}
 
-The full pipline constist of $n$ steps:
+The full pipline consists of $n$ steps:
 
 \begin{enumerate}
 \item Find alignment seeds using a fast suffix array method (vmatch) for
index 1c71936..f55c1e2 100644 (file)
@@ -15,7 +15,7 @@ Alignment::Alignment(int numQPlifs, int numq, bool use_qscores) {
       max_len = 0;
       min_len = 0;
       cache = 0;
-      enum ETransformType transform = T_LINEAR;
+      //enum ETransformType transform = T_LINEAR;
       id = 0;
       name = 0;
       use_svm = 0;
@@ -86,7 +86,8 @@ void Alignment::myalign(int nr_paths_p, char* dna, int dna_len_p, char* est,
   int* max_score_positions = new int[nr_paths*2];
 
   Pre_score** matrices = new Pre_score*[nr_paths];
-  for (int z=0; z<nr_paths; z++) {
+  //for (int z=0; z<nr_paths; z++) {
+  for (size_t  z=0; z<nr_paths; z++) {
       matrices[z] = new Pre_score[dna_len * est_len];
   }
 
@@ -146,7 +147,8 @@ void Alignment::myalign(int nr_paths_p, char* dna, int dna_len_p, char* est,
   
   qualityFeaturesAllPaths= new penalty_struct*[nr_paths];
 
-  for (int z=0; z<nr_paths; z++) {
+  //for (int z=0; z<nr_paths; z++) {
+  for (size_t z=0; z<nr_paths; z++) {
     result_length = 0 ;
     
     int* s_align = splice_align + (dna_len-1)*z;  //pointer
@@ -265,7 +267,8 @@ void Alignment::getAlignmentResults(int* s_align, int* e_align,
    if (use_quality_scores) {
       penalty_struct currentPlif;
       int ctr=0;
-      for (int z=0; z<nr_paths; z++) {
+      //for (int z=0; z<nr_paths; z++) {
+      for (size_t z=0; z<nr_paths; z++) {
          for(int estChar=1;estChar<6;estChar++) {
             for(int dnaChar=0;dnaChar<6;dnaChar++) {
 
@@ -287,7 +290,7 @@ void Alignment::getAlignmentResults(int* s_align, int* e_align,
 
 void Alignment::getAlignmentArrays(int* dna_align, int* est_align) {
 
-   int idx;
+   size_t idx;
    for(idx=0; idx<result_len; idx++) {
       dna_align[idx] = DNA_ARRAY[idx];
       est_align[idx] = EST_ARRAY[idx];
@@ -326,7 +329,8 @@ PyObject* Alignment::getAlignmentResultsNew() {
    if (use_quality_scores) {
       penalty_struct currentPlif;
       int ctr=0;
-      for (int z=0; z<nr_paths; z++) {
+      for (size_t z=0; z<nr_paths; z++) {
+      //for (int z=0; z<nr_paths; z++) {
          for(int estChar=1;estChar<6;estChar++) {
             for(int dnaChar=0;dnaChar<6;dnaChar++) {
 
index da809c3..f46ed3b 100644 (file)
@@ -26,20 +26,37 @@ from createAlignmentFileFromPrediction import create_alignment_file
 
 import gridtools
 
+from utils import get_slices
+
 jp = os.path.join
 
 
 class ClusterTask(Thread):
    """
    This class..
+
+   Every task creates a status file.
+   All cluster jobs submit then their exit status to this status file.
+
+   Job / status
+
+   1 success
+   2 failed
+   3 waiting
+   
+   means then job with id 1 terminated with success.
    """
    
-   def __init__(self):
+   def __init__(self,global_settings):
       self.sleep_time = 0
 
       # this list stores the cluster/local jobs objects
       self.functionJobs = []
 
+      self.global_settings = global_settings
+
+      #self.allJobIds = {}
+
 
    def createJobs(self):
       pass
@@ -47,13 +64,37 @@ class ClusterTask(Thread):
 
    def submit(self):
       for current_job in self.functionJobs:
-         (sid, jobids) = submit_jobs([functionJobs])
-         time.sleep(self.sleep_time)
+         self.sid, self.jobids = submit_jobs([functionJobs])
+
+   def restart(self,id):
+      pass
 
 
    def checkIfTaskFinished(self):
-      pass
-   
+      """
+      currentJobStatus = {}
+      for line in open(self.statusFile):
+         id,status = line.split()
+         currentJobStatus[id] = status
+
+      for key in self.allJobIds.keys():
+         try:
+            self.currentJobStatus[key]
+         except:
+            self.currentJobStatus[key] = 'no response'
+      """
+
+      print 'checking whether finished'
+      while not get_status(self.sid, self.jobids):
+         time.sleep(7)
+      print 'collecting jobs'
+      retjobs = collect_jobs(sid, jobids, myjobs)
+      print "ret fields AFTER execution on cluster"
+      for (i, job) in enumerate(retjobs):
+         print "Job #", i, "- ret: ", job.ret
+
+      print '--------------'
+
 
 
 class ApproximationTask(ClusterTask):
@@ -65,26 +106,22 @@ class ApproximationTask(ClusterTask):
 
 
    def g_heuristic(run_fname,data_fname,param_fname,result_fname):
-      #print run_fname,data_fname,param_fname,result_fname
       ph1 = PipelineHeuristic(run_fname,data_fname,param_fname,result_fname)
       ph1.filter()
 
       return 'finished filtering set %s.' % data_fname
 
    def createJobs(self):
-      num_splits = 25
+      num_splits = self.global_settings['num_splits']
 
       run_dir  = '/fml/ag-raetsch/home/fabio/tmp/newest_run/alignment/run_enable_quality_scores_+_enable_splice_signals_+_enable_intron_length_+'
-      #data_dir = '/fml/ag-raetsch/home/fabio/tmp/lyrata_analysis/'
-
-      data_dir = '/fml/ag-raetsch/home/fabio/tmp/vmatch_evaluation/main'
-
+      param_fname    = jp(run_dir,'param_526.pickle')
       run_fname      = jp(run_dir,'run_obj.pickle')
 
-      #original_map_fname = '/fml/ag-raetsch/home/fabio/tmp/vmatch_evaluation/main/map.vm'
-      #split_file(original_map_fname,data_dir,num_splits)
+      data_dir = '/fml/ag-raetsch/home/fabio/tmp/vmatch_evaluation/main'
 
-      param_fname    = jp(run_dir,'param_526.pickle')
+      original_map_fname = self.global_settings['read_ascii_data_fn']
+      split_file(original_map_fname,data_dir,num_splits)
 
       functionJobs=[]
 
@@ -118,26 +155,6 @@ class AlignmentTask(ClusterTask):
       ClusterTask.__init__(self)
 
 
-   def get_slices(dataset_size,num_nodes):
-      all_instances = []
-
-      part = dataset_size / num_nodes
-      begin = 0
-      end = 0
-      for idx in range(1,num_nodes+1):
-         
-         if idx == num_nodes:
-            begin = end
-            end   = dataset_size
-         else:
-            begin = end
-            end = begin+part
-
-         params = (begin,end)
-
-         all_instances.append(params)
-
-      return all_instances
 
 
    def makeJobs(run,dataset_fn,chunks,param):
@@ -163,6 +180,8 @@ class AlignmentTask(ClusterTask):
 
       """
 
+      num_splits = self.global_settings['num_splits']
+
       jp = os.path.join
 
       run_dir = '/fml/ag-raetsch/home/fabio/tmp/newest_run/alignment/saved_run'
@@ -180,8 +199,6 @@ class AlignmentTask(ClusterTask):
 
       print 'Found %d keys for prediction.' % len(prediction_keys)
 
-      num_splits = 25
-      #num_splits = 1
       slices = get_slices(len(prediction_keys),num_splits)
       chunks = []
       for idx,slice in enumerate(slices):
index 53c3795..9ad4abd 100644 (file)
@@ -1,6 +1,14 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+# 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.
+#
+# Written (W) 2008 Fabio De Bona
+# Copyright (C) 2008 Max-Planck-Society
+
 import math
 import numpy.matlib
 import QPalmaDP
diff --git a/qpalma/utils.py b/qpalma/utils.py
new file mode 100644 (file)
index 0000000..6fb55c2
--- /dev/null
@@ -0,0 +1,260 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import pdb
+import os.path
+
+from numpy.matlib import mat,zeros,ones,inf
+
+import palma.palma_utils as pu
+from palma.output_formating import print_results
+
+# some useful constants
+
+extended_alphabet = ['-','a','c','g','t','n','[',']']
+alphabet          = ['-','a','c','g','t','n']
+
+alignment_alphabet   = ['-','a','c','g','t','n','z']
+
+
+def print_prediction(example):
+   dna_array   = example['dna_array']
+   read_array  = example['read_array']
+
+   dna   = map(lambda x: alignment_alphabet[x],dna_array)
+   read  = map(lambda x: alignment_alphabet[x],read_array)
+
+   spliceAlign = example['spliceAlign']
+   estAlign    = example['estAlign']
+
+   line1,line2,line3 = pprint_alignment(spliceAlign, estAlign, dna, read)
+   
+   result = '%s\n%s\n%s' %(line1,line2,line3)
+   return result
+
+def calc_info(acc,don,exons,qualities):
+   min_score = 100
+   max_score = -100
+
+   for elem in acc:
+      for score in elem:
+         if score != -inf:
+            min_score = min(min_score,score)
+            max_score = max(max_score,score)
+
+   print 'Acceptors max/min: %f / %f' % (max_score,min_score)
+
+   min_score = 100
+   max_score = -100
+
+   for elem in don:
+      for score in elem:
+         if score != -inf:
+            min_score = min(min_score,score)
+            max_score = max(max_score,score)
+
+   print 'Donor max/min: %f / %f' % (max_score,min_score)
+
+   min_score = 10000
+   max_score = 0
+   mean_intron_len = 0
+
+   for elem in exons:
+      intron_len = int(elem[1,0] - elem[0,1])
+      mean_intron_len += intron_len
+      min_score = min(min_score,intron_len)
+      max_score = max(max_score,intron_len)
+
+   mean_intron_len /= 1.0*len(exons)
+   print 'Intron length max/min: %d / %d mean length %f' % (max_score,min_score,mean_intron_len)
+
+   min_score = 10000
+   max_score = 0
+   mean_quality = 0
+
+   for qVec in qualities:
+      for elem in qVec:
+         min_score = min(min_score,elem)
+         max_score = max(max_score,elem)
+
+   print 'Quality values max/min: %d / %d mean' % (max_score,min_score)
+
+
+def calc_stat(Acceptor,Donor,Exons):
+   maxAcc = -100
+   minAcc = 100
+   maxDon = -100
+   minDon = 100
+
+   acc_vec_pos = []
+   acc_vec_neg = []
+   don_vec_pos = []
+   don_vec_neg = []
+
+   for jdx in range(len(Acceptors)):
+      currentExons = Exons[jdx]
+      currentAcceptor = Acceptors[jdx]
+      currentAcceptor = currentAcceptor[1:]
+      currentAcceptor.append(-inf)
+      currentDonor = Donors[jdx]
+
+      for idx,elem in enumerate(currentAcceptor):
+         if idx == (int(currentExons[1,0])-1): # acceptor site
+            acc_vec_pos.append(elem)
+         else:
+            acc_vec_neg.append(elem)
+
+      for idx,elem in enumerate(currentDonor):
+         if idx == (int(currentExons[0,1])): # donor site
+            don_vec_pos.append(elem)
+         else:
+            don_vec_neg.append(elem)
+
+   acc_pos = [elem for elem in acc_vec_pos if elem != -inf]
+   acc_neg = [elem for elem in acc_vec_neg if elem != -inf]
+   don_pos = [elem for elem in don_vec_pos if elem != -inf]
+   don_neg = [elem for elem in don_vec_neg if elem != -inf]
+
+   for idx in range(len(Sequences)):
+      acc = [elem for elem in Acceptors[idx] if elem != -inf]
+      maxAcc = max(max(acc),maxAcc)
+      minAcc = min(min(acc),minAcc)
+
+      don = [elem for elem in Donors[idx] if elem != -inf]
+      maxDon = max(max(don),maxDon)
+      minDon = min(min(don),minDon)
+
+
+def pprint_alignment(_newSpliceAlign,_newEstAlign, dna_array, est_array):
+   (qStart, qEnd, tStart, tEnd, num_exons, qExonSizes, qStarts, qEnds, tExonSizes, tStarts, tEnds) =\
+         pu.get_splice_info(_newSpliceAlign,_newEstAlign)
+
+   t_strand = '+'
+   translation = '-ACGTN_'    #how aligned est and dna sequence is displayed
+                              #(gap_char, 5 nucleotides, intron_char) 
+   comparison_char = '| '     #first: match_char, second: intron_char
+
+   (exon_length, identity, ssQuality, exonQuality, comparison, qIDX, tIDX) =\
+             pu.comp_identity(dna_array, est_array, t_strand, qStart, tStart, translation, comparison_char)
+
+   first_identity = None
+   last_identity = None 
+   for i in range(len(comparison)):
+    if comparison[i] == '|' and first_identity is None: 
+      first_identity = i 
+    if comparison[-i] == '|' and last_identity is None: 
+      last_identity = len(comparison) - i - 1
+
+   try:
+      for idx in range(len(dna_array)):
+         dna_array[idx] = translation[int(dna_array[idx])]
+         est_array[idx] = translation[int(est_array[idx])]
+   except:
+      #pdb.set_trace()
+      pass
+
+   line1 = "".join(dna_array)
+   line2 = comparison
+   line3 = "".join(est_array)
+
+   return line1,line2,line3
+
+
+def get_alignment(_newSpliceAlign,_newEstAlign, dna_array, est_array):
+   return pu.get_splice_info(_newSpliceAlign,_newEstAlign)
+
+
+##########
+
+def split_file(filename,result_dir,num_parts):
+   """
+   Splits a file of n lines into num_parts parts
+   """
+
+   jp = os.path.join
+
+   all_intervals = []
+
+   print 'counting lines'
+   line_ctr = 0
+   for line in open(filename,'r'):
+      line_ctr += 1
+
+   print 'found %d lines' % line_ctr
+
+   part_size = line_ctr / num_parts
+   begin = 0
+   end = 0
+
+   for idx in range(1,num_parts+1):
+      begin = end
+
+      if idx == num_parts:
+         end = line_ctr
+      else:
+         end = begin+part_size+1
+
+      all_intervals.append((begin,end))
+
+   parts_fn = []
+   for pos,params in enumerate(all_intervals):
+      beg,end = params
+      out_fn = jp(result_dir,'map.part_%d'%pos)
+      print out_fn
+      parts_fn.append(out_fn)
+      out_fh = open(out_fn,'w+')
+
+   parts_fn.reverse()
+   all_intervals.reverse()
+
+   lineCtr = 0
+   beg = -1
+   end = -1
+   in_fh = open(filename,'r')
+   while True:
+      line = in_fh.readline()
+      if line == '':
+         break
+
+      if beg <= lineCtr < end:
+         out_fh.write(line)
+         lineCtr += 1
+      else:
+         (beg,end) = all_intervals.pop()
+         out_fn = parts_fn.pop()
+         out_fh.close()
+         out_fh = open(out_fn,'w+')
+         out_fh.write(line)
+
+   out_fh.close()
+
+
+def get_slices(dataset_size,num_nodes):
+   """
+   Given the size of the dataset and the number of nodes which shall be used
+   this function returns the slice of the dataset for each node.
+   """
+
+   all_instances = []
+
+   part = dataset_size / num_nodes
+   begin = 0
+   end = 0
+   for idx in range(1,num_nodes+1):
+      
+      if idx == num_nodes:
+         begin = end
+         end   = dataset_size
+      else:
+         begin = end
+         end = begin+part
+
+      params = (begin,end)
+
+      all_instances.append(params)
+
+   return all_instances
+
+
+if __name__ == '__main__':
+   split_file('/fml/ag-raetsch/home/fabio/tmp/lyrata_analysis/map.vm','/tmp',25)
diff --git a/scripts/Utils.py b/scripts/Utils.py
deleted file mode 100644 (file)
index db685d1..0000000
+++ /dev/null
@@ -1,235 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import pdb
-import os.path
-
-from numpy.matlib import mat,zeros,ones,inf
-
-import palma.palma_utils as pu
-from palma.output_formating import print_results
-
-# some useful constants
-
-extended_alphabet = ['-','a','c','g','t','n','[',']']
-alphabet          = ['-','a','c','g','t','n']
-
-alignment_alphabet   = ['-','a','c','g','t','n','z']
-
-
-def print_prediction(example):
-   dna_array   = example['dna_array']
-   read_array  = example['read_array']
-
-   dna   = map(lambda x: alignment_alphabet[x],dna_array)
-   read  = map(lambda x: alignment_alphabet[x],read_array)
-
-   spliceAlign = example['spliceAlign']
-   estAlign    = example['estAlign']
-
-   line1,line2,line3 = pprint_alignment(spliceAlign, estAlign, dna, read)
-   
-   result = '%s\n%s\n%s' %(line1,line2,line3)
-   return result
-
-def calc_info(acc,don,exons,qualities):
-   min_score = 100
-   max_score = -100
-
-   for elem in acc:
-      for score in elem:
-         if score != -inf:
-            min_score = min(min_score,score)
-            max_score = max(max_score,score)
-
-   print 'Acceptors max/min: %f / %f' % (max_score,min_score)
-
-   min_score = 100
-   max_score = -100
-
-   for elem in don:
-      for score in elem:
-         if score != -inf:
-            min_score = min(min_score,score)
-            max_score = max(max_score,score)
-
-   print 'Donor max/min: %f / %f' % (max_score,min_score)
-
-   min_score = 10000
-   max_score = 0
-   mean_intron_len = 0
-
-   for elem in exons:
-      intron_len = int(elem[1,0] - elem[0,1])
-      mean_intron_len += intron_len
-      min_score = min(min_score,intron_len)
-      max_score = max(max_score,intron_len)
-
-   mean_intron_len /= 1.0*len(exons)
-   print 'Intron length max/min: %d / %d mean length %f' % (max_score,min_score,mean_intron_len)
-
-   min_score = 10000
-   max_score = 0
-   mean_quality = 0
-
-   for qVec in qualities:
-      for elem in qVec:
-         min_score = min(min_score,elem)
-         max_score = max(max_score,elem)
-
-   print 'Quality values max/min: %d / %d mean' % (max_score,min_score)
-
-
-def calc_stat(Acceptor,Donor,Exons):
-   maxAcc = -100
-   minAcc = 100
-   maxDon = -100
-   minDon = 100
-
-   acc_vec_pos = []
-   acc_vec_neg = []
-   don_vec_pos = []
-   don_vec_neg = []
-
-   for jdx in range(len(Acceptors)):
-      currentExons = Exons[jdx]
-      currentAcceptor = Acceptors[jdx]
-      currentAcceptor = currentAcceptor[1:]
-      currentAcceptor.append(-inf)
-      currentDonor = Donors[jdx]
-
-      for idx,elem in enumerate(currentAcceptor):
-         if idx == (int(currentExons[1,0])-1): # acceptor site
-            acc_vec_pos.append(elem)
-         else:
-            acc_vec_neg.append(elem)
-
-      for idx,elem in enumerate(currentDonor):
-         if idx == (int(currentExons[0,1])): # donor site
-            don_vec_pos.append(elem)
-         else:
-            don_vec_neg.append(elem)
-
-   acc_pos = [elem for elem in acc_vec_pos if elem != -inf]
-   acc_neg = [elem for elem in acc_vec_neg if elem != -inf]
-   don_pos = [elem for elem in don_vec_pos if elem != -inf]
-   don_neg = [elem for elem in don_vec_neg if elem != -inf]
-
-   for idx in range(len(Sequences)):
-      acc = [elem for elem in Acceptors[idx] if elem != -inf]
-      maxAcc = max(max(acc),maxAcc)
-      minAcc = min(min(acc),minAcc)
-
-      don = [elem for elem in Donors[idx] if elem != -inf]
-      maxDon = max(max(don),maxDon)
-      minDon = min(min(don),minDon)
-
-
-def pprint_alignment(_newSpliceAlign,_newEstAlign, dna_array, est_array):
-   (qStart, qEnd, tStart, tEnd, num_exons, qExonSizes, qStarts, qEnds, tExonSizes, tStarts, tEnds) =\
-         pu.get_splice_info(_newSpliceAlign,_newEstAlign)
-
-   t_strand = '+'
-   translation = '-ACGTN_'    #how aligned est and dna sequence is displayed
-                              #(gap_char, 5 nucleotides, intron_char) 
-   comparison_char = '| '     #first: match_char, second: intron_char
-
-   (exon_length, identity, ssQuality, exonQuality, comparison, qIDX, tIDX) =\
-             pu.comp_identity(dna_array, est_array, t_strand, qStart, tStart, translation, comparison_char)
-
-   first_identity = None
-   last_identity = None 
-   for i in range(len(comparison)):
-    if comparison[i] == '|' and first_identity is None: 
-      first_identity = i 
-    if comparison[-i] == '|' and last_identity is None: 
-      last_identity = len(comparison) - i - 1
-
-   try:
-      for idx in range(len(dna_array)):
-         dna_array[idx] = translation[int(dna_array[idx])]
-         est_array[idx] = translation[int(est_array[idx])]
-   except:
-      #pdb.set_trace()
-      pass
-
-   line1 = "".join(dna_array)
-   line2 = comparison
-   line3 = "".join(est_array)
-
-   return line1,line2,line3
-
-
-def get_alignment(_newSpliceAlign,_newEstAlign, dna_array, est_array):
-   return pu.get_splice_info(_newSpliceAlign,_newEstAlign)
-
-
-##########
-
-def split_file(filename,result_dir,num_parts):
-   """
-   Splits a file of n lines into num_parts parts
-   """
-
-   jp = os.path.join
-
-   all_intervals = []
-
-   print 'counting lines'
-   line_ctr = 0
-   for line in open(filename,'r'):
-      line_ctr += 1
-
-   print 'found %d lines' % line_ctr
-
-   part_size = line_ctr / num_parts
-   begin = 0
-   end = 0
-
-   for idx in range(1,num_parts+1):
-      begin = end
-
-      if idx == num_parts:
-         end = line_ctr
-      else:
-         end = begin+part_size+1
-
-      all_intervals.append((begin,end))
-
-   parts_fn = []
-   for pos,params in enumerate(all_intervals):
-      beg,end = params
-      out_fn = jp(result_dir,'map.part_%d'%pos)
-      print out_fn
-      parts_fn.append(out_fn)
-      out_fh = open(out_fn,'w+')
-
-   parts_fn.reverse()
-   all_intervals.reverse()
-
-   lineCtr = 0
-   beg = -1
-   end = -1
-   in_fh = open(filename,'r')
-   while True:
-      line = in_fh.readline()
-      if line == '':
-         break
-
-      if beg <= lineCtr < end:
-         out_fh.write(line)
-         lineCtr += 1
-      else:
-         (beg,end) = all_intervals.pop()
-         out_fn = parts_fn.pop()
-         out_fh.close()
-         out_fh = open(out_fn,'w+')
-         out_fh.write(line)
-
-   out_fh.close()
-
-
-if __name__ == '__main__':
-   split_file('/fml/ag-raetsch/home/fabio/tmp/lyrata_analysis/map.vm','/tmp',25)
-   
-
index 1fdd697..a925bbe 100644 (file)
@@ -1,6 +1,14 @@
 #!/usr/bin/env python 
 # -*- coding: utf-8 -*- 
 
+# 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.
+#
+# Written (W) 2008 Fabio De Bona
+# Copyright (C) 2008 Max-Planck-Society
+
 import cPickle
 import sys
 import pdb
index 6dc82f8..17d64e0 100644 (file)
@@ -12,8 +12,6 @@
 #
 # This file contains the main interface to the QPalma pipeline.
 #
-#
-#
 
 from optparse import OptionParser
 
@@ -34,6 +32,12 @@ def create_option_parser():
 
    return parser
 
+global_settings = {\
+'experiment_dir':'/fml/ag-raetsch/...',\
+'read_ascii_data_fn':'/fml/ag-raetsch/...',\
+'num_splits':50
+'global_log_fn':'~/qpalma.log'
+}
 
 
 
@@ -55,46 +59,64 @@ class System:
       parser = create_option_parser()
       (options, args) = parser.parse_args()
 
+   def training(self):
+      """
+      This function is responsible for the whole training process. It first
+      converts the data to the right format needed by QPalma for the training
+      algorithm.
+      """
 
-   def run(self):
+      pre_task = TrainingPreprocessingTask(global_settings,run_specific_settings)
+      pre_task.createJobs()
+      pre_task.submit() 
+      while pre_task.checkIfTaskFinished() == False:
+         sleep(20)
+      
+
+   def prediction(self):
+      """
+      This function encapsulates all steps needed to perform a prediction. Given
+      the parameter of the training and paths to a prediction set it will
+      generate several output files containing the spliced alignments
+      """
 
       # Before creating a candidate spliced read dataset we have to first filter
       # the matches from the first seed finding run.
 
-      grid_heuristic()
-
-      # approx_task = ApproximationTask(...)
-      # approx_task.createJobs()
-      # approx_task.submit()
-      # approx_task.checkIfTaskFinished()
-
+      approx_task = ApproximationTask(config_obj)
+      approx_task.createJobs()
+      approx_task.submit()
+      approx_task.checkIfTaskFinished()
+      
       # After filtering combine the filtered matches from the first run and the
       # found matches from the second run to a full dataset
 
-      createNewDataset
-      
-      # pre_task = PreprocessingTask(...)
-      # pre_task.createJobs()
-      # pre_task.submit()
+      pre_task = PreprocessingTask(...)
+      pre_task.createJobs()
+      pre_task.submit() 
+      while pre_task.checkIfTaskFinished() == False:
+         sleep(20)
 
       # Now that we have a dataset we can perform the accurate alignments for this
       # data
 
-      grid_predict()
-
-      # align_task = AlignmentTask(...)
-      # align_task.createJobs()
-      # align_task.submit()
+      align_task = AlignmentTask(...)
+      align_task.createJobs()
+      align_task.submit()
+      while align_task.checkIfTaskFinished() == False:
+         sleep(20)
 
       # The results of the above alignment step can be converted to a data format
-      # needed for further postprocessing
-
-      grid_alignment()
+      # needed for further postprocessing.
 
-      # post_task = PostprocessingTask(...)
-      # post_task.createJobs()
-      # post_task.submit()
+      post_task = PostprocessingTask(...)
+      post_task.createJobs()
+      post_task.submit()
+      while post_task.checkIfTaskFinished() == False:
+         sleep(20)
 
+      print "Success!"
+   
 
 if __name__ == '__main__':
    system_obj = System() 
index c65ac1e..832c155 100644 (file)
--- a/setup.py
+++ b/setup.py
@@ -14,4 +14,5 @@ setup (name = 'QPalma'
    ext_package = "qpalma",
    #ext_modules = extmods,
    package_dir = {"qpalma": "python"},
+   #ext_modules=Extension('QPalmaDP',[''])
    packages = ["qpalma"])