From 20be011f8b33fcde94037af19e403d3b76d5c9d1 Mon Sep 17 00:00:00 2001
From: Zachary Sloan
Date: Fri, 13 Sep 2013 14:29:18 -0500
Subject: Added file that will convert genofiles to plink ped/map files

---
 wqflask/wqflask/my_pylmm/data/geno_to_ped.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 wqflask/wqflask/my_pylmm/data/geno_to_ped.py

diff --git a/wqflask/wqflask/my_pylmm/data/geno_to_ped.py b/wqflask/wqflask/my_pylmm/data/geno_to_ped.py
new file mode 100644
index 00000000..9091ad9a
--- /dev/null
+++ b/wqflask/wqflask/my_pylmm/data/geno_to_ped.py
@@ -0,0 +1,22 @@
+from __future__ import absolute_import, division, print_function
+
+import csv
+
+class ConvertToPed(object):
+
+    def __init__(self, input_file, output_file):
+        self.input_file = input_file
+        self.output_file = output_file
+        
+    def convert(self):
+    
+        self.haplotype_notation = {
+        '@mat': "1",
+        '@pat': "0",
+        '@het': "0.5",
+        '@unk': "NA"
+        }
+        
+        with open(self.output_file, "w") as self.output_fh:
+            self.process_csv()
+        
\ No newline at end of file
-- 
cgit v1.2.3


From ce5d2b86af694c266cc0159be0438f187a058c20 Mon Sep 17 00:00:00 2001
From: Zachary Sloan
Date: Tue, 24 Sep 2013 13:11:21 -0500
Subject: Fixed the db_tools import in mrna_assay_tissue_data.py

Added file for the interval mapping page and wrote code that
gets/sets some parameters
---
 wqflask/base/mrna_assay_tissue_data.py             |   4 +-
 .../wqflask/interval_mapping/interval_mapping.py   | 307 +++++++++++++++++++++
 2 files changed, 309 insertions(+), 2 deletions(-)
 create mode 100644 wqflask/wqflask/interval_mapping/interval_mapping.py

diff --git a/wqflask/base/mrna_assay_tissue_data.py b/wqflask/base/mrna_assay_tissue_data.py
index 8ae71858..a08f3f21 100644
--- a/wqflask/base/mrna_assay_tissue_data.py
+++ b/wqflask/base/mrna_assay_tissue_data.py
@@ -4,8 +4,8 @@ import collections
 
 from flask import g
 
-from utility import dbtools
-from uitility import Bunch
+from utility import db_tools
+from utility import Bunch
 
 from MySQLdb import escape_string as escape
 
diff --git a/wqflask/wqflask/interval_mapping/interval_mapping.py b/wqflask/wqflask/interval_mapping/interval_mapping.py
new file mode 100644
index 00000000..3ec08f6b
--- /dev/null
+++ b/wqflask/wqflask/interval_mapping/interval_mapping.py
@@ -0,0 +1,307 @@
+from __future__ import absolute_import, print_function, division
+
+from base.trait import GeneralTrait
+from base import data_set  #import create_dataset
+
+from pprint import pformat as pf
+
+import string
+import sys
+import os
+import collections
+
+import numpy as np
+from scipy import linalg
+
+import simplejson as json
+
+#from redis import Redis
+
+
+from base.trait import GeneralTrait
+from base import data_set
+from base import species
+from base import webqtlConfig
+from wqflask.my_pylmm.data import prep_data
+from wqflask.my_pylmm.pyLMM import lmm
+from wqflask.my_pylmm.pyLMM import input
+from utility import helper_functions
+from utility import Plot, Bunch
+from utility import temp_data
+
+from utility.benchmark import Bench
+
+
+class IntervalMapping(object):
+
+    def __init__(self, start_vars, temp_uuid):
+
+        #Currently only getting trait data for one trait, but will need
+        #to change this to accept multiple traits once the collection page is implemented
+        helper_functions.get_species_dataset_trait(self, start_vars)
+
+        tempdata = temp_data.TempData(temp_uuid)
+        
+        self.samples = [] # Want only ones with values
+        self.vals = []
+
+        for sample in self.dataset.group.samplelist:
+            value = start_vars['value:' + sample]
+            self.samples.append(str(sample))
+            self.vals.append(value)
+ 
+        self.set_options(start_vars)
+ 
+        self.gen_data(tempdata)
+
+        #Get chromosome lengths for drawing the interval map plot
+        chromosome_mb_lengths = {}
+        for key in self.species.chromosomes.chromosomes.keys():
+            chromosome_mb_lengths[key] = self.species.chromosomes.chromosomes[key].mb_length
+        
+        self.js_data = dict(
+            chromosomes = chromosome_mb_lengths,
+            qtl_results = self.qtl_results,
+        )
+
+    def get_qtl_results(self):
+        """Gets the LOD (or LRS) score at each marker in order do the qtl mapping"""
+        
+        
+        #INTERCROSS = (self.genotype.type=="intercross")
+
+        #THESE ARE OLD COMMENTS
+        #draw the LRS scale
+        #We first determine whether or not we are using a sliding scale.
+        #If so, we need to compute the maximum LRS value to determine where the max y-value should be, and call this LRSMax.
+        #LRSTop is then defined to be above the LRSMax by enough to add one additional LRSScale increment.
+        #if we are using a set-scale, then we set LRSTop to be the user's value, and LRSMax doesn't matter.
+    
+        #if self.lrs_lod == 'LOD':
+        #    lodm = self.LODFACTOR
+        #else:
+        #    lodm = 1.0
+                
+        if self.lrsMax <= 0:  #sliding scale
+            LRSMax = max(map(max, self.qtlresults)).lrs
+            #genotype trait will give infinite LRS
+            LRSMax = min(LRSMax, webqtlConfig.MAXLRS)
+            if self.permChecked and not self.multipleInterval:
+                self.significance = min(self.significance, webqtlConfig.MAXLRS)
+                self.suggestive = min(self.suggestive, webqtlConfig.MAXLRS)
+                LRSMax = max(self.significance, LRSMax)
+        else:
+            LRSMax = self.lrsMax*lodm
+            
+        if LRSMax/lodm > 100:
+            LRSScale = 20.0
+        elif LRSMax/lodm > 20:
+            LRSScale = 5.0
+        elif LRSMax/lodm > 7.5:
+            LRSScale = 2.5
+        else:
+            LRSScale = 1.0
+    
+        LRSAxisList = Plot.frange(LRSScale, LRSMax/lodm, LRSScale)
+        #make sure the user's value appears on the y-axis
+        #update by NL 6-21-2011: round the LOD value to 100 when LRSMax is equal to 460
+        LRSAxisList.append(round(LRSMax/lodm)) 
+    
+        #draw the "LRS" or "LOD" string to the left of the axis
+        LRSScaleFont=pid.Font(ttf="verdana", size=14*fontZoom, bold=0)
+        LRSLODFont=pid.Font(ttf="verdana", size=14*zoom*1.5, bold=0)
+        yZero = yTopOffset + plotHeight
+        
+    
+        canvas.drawString(self.LRS_LOD, xLeftOffset - canvas.stringWidth("999.99", font=LRSScaleFont) - 10*zoom, \
+                          yZero - 150, font=LRSLODFont, color=pid.black, angle=90)
+                        
+        for item in LRSAxisList:
+            yLRS = yZero - (item*lodm/LRSMax) * LRSHeightThresh
+            canvas.drawLine(xLeftOffset, yLRS, xLeftOffset - 4, yLRS, color=self.LRS_COLOR, width=1*zoom)
+            scaleStr = "%2.1f" % item
+            canvas.drawString(scaleStr, xLeftOffset-4-canvas.stringWidth(scaleStr, font=LRSScaleFont)-5, yLRS+3, font=LRSScaleFont, color=self.LRS_COLOR)
+    
+    
+        #"Significant" and "Suggestive" Drawing Routine
+        # ======= Draw the thick lines for "Significant" and "Suggestive" =====  (crowell: I tried to make the SNPs draw over these lines, but piddle wouldn't have it...)
+        if self.permChecked and not self.multipleInterval:
+            significantY = yZero - self.significance*LRSHeightThresh/LRSMax
+            suggestiveY = yZero - self.suggestive*LRSHeightThresh/LRSMax
+            startPosX = xLeftOffset
+            for i, _chr in enumerate(self.genotype):
+                rightEdge = int(startPosX + self.ChrLengthDistList[i]*plotXScale - self.SUGGESTIVE_WIDTH/1.5)
+                canvas.drawLine(startPosX+self.SUGGESTIVE_WIDTH/1.5, suggestiveY, rightEdge, suggestiveY, color=self.SUGGESTIVE_COLOR,
+                    width=self.SUGGESTIVE_WIDTH*zoom, clipX=(xLeftOffset, xLeftOffset + plotWidth-2))
+                canvas.drawLine(startPosX+self.SUGGESTIVE_WIDTH/1.5, significantY, rightEdge, significantY, color=self.SIGNIFICANT_COLOR, 
+                    width=self.SIGNIFICANT_WIDTH*zoom, clipX=(xLeftOffset, xLeftOffset + plotWidth-2))
+                sugg_coords = "%d, %d, %d, %d" % (startPosX, suggestiveY-2, rightEdge + 2*zoom, suggestiveY+2)
+                sig_coords = "%d, %d, %d, %d" % (startPosX, significantY-2, rightEdge + 2*zoom, significantY+2)
+                if self.LRS_LOD == 'LRS':
+                    sugg_title = "Suggestive LRS = %0.2f" % self.suggestive
+                    sig_title = "Significant LRS = %0.2f" % self.significance
+                else:
+                    sugg_title = "Suggestive LOD = %0.2f" % (self.suggestive/4.61)
+                    sig_title = "Significant LOD = %0.2f" % (self.significance/4.61)
+                Areas1 = HT.Area(shape='rect',coords=sugg_coords,title=sugg_title)
+                Areas2 = HT.Area(shape='rect',coords=sig_coords,title=sig_title)
+                gifmap.areas.append(Areas1)
+                gifmap.areas.append(Areas2)
+    
+                startPosX +=  (self.ChrLengthDistList[i]+self.GraphInterval)*plotXScale
+    
+    
+        if self.multipleInterval:
+            lrsEdgeWidth = 1
+        else:
+            additiveMax = max(map(lambda X : abs(X.additive), self.qtlresults[0]))
+            if INTERCROSS:
+                dominanceMax = max(map(lambda X : abs(X.dominance), self.qtlresults[0]))
+            else:
+                dominanceMax = -1
+            lrsEdgeWidth = 2
+        for i, qtlresult in enumerate(self.qtlresults):
+            m = 0
+            startPosX = xLeftOffset
+            thisLRSColor = self.colorCollection[i]
+            for j, _chr in enumerate(self.genotype):
+                LRSCoordXY = []
+                AdditiveCoordXY = []
+                DominanceCoordXY = []
+                for k, _locus in enumerate(_chr):
+                    if self.plotScale == 'physic':
+                        Xc = startPosX + (_locus.Mb-startMb)*plotXScale
+                    else:
+                        Xc = startPosX + (_locus.cM-_chr[0].cM)*plotXScale
+                    # updated by NL 06-18-2011: 
+                    # fix the over limit LRS graph issue since genotype trait may give infinite LRS;
+                    # for any lrs is over than 460(LRS max in this system), it will be reset to 460
+                    if 	qtlresult[m].lrs> 460 or qtlresult[m].lrs=='inf':
+                        Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRSMax
+                    else:	
+                        Yc = yZero - qtlresult[m].lrs*LRSHeightThresh/LRSMax						
+    
+                    LRSCoordXY.append((Xc, Yc))
+                    if not self.multipleInterval and self.additiveChecked:
+                        Yc = yZero - qtlresult[m].additive*AdditiveHeightThresh/additiveMax
+                        AdditiveCoordXY.append((Xc, Yc))
+                    if not self.multipleInterval and INTERCROSS and self.additiveChecked:
+                        Yc = yZero - qtlresult[m].dominance*DominanceHeightThresh/dominanceMax
+                        DominanceCoordXY.append((Xc, Yc))
+                    m += 1
+                canvas.drawPolygon(LRSCoordXY,edgeColor=thisLRSColor,closed=0, edgeWidth=lrsEdgeWidth, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                if not self.multipleInterval and self.additiveChecked:
+                    plusColor = self.ADDITIVE_COLOR_POSITIVE
+                    minusColor = self.ADDITIVE_COLOR_NEGATIVE
+                    for k, aPoint in enumerate(AdditiveCoordXY):
+                        if k > 0:
+                            Xc0, Yc0 = AdditiveCoordXY[k-1]
+                            Xc, Yc = aPoint
+                            if (Yc0-yZero)*(Yc-yZero) < 0:
+                                if Xc == Xc0: #genotype , locus distance is 0
+                                    Xcm = Xc
+                                else:	
+                                    Xcm = (yZero-Yc0)/((Yc-Yc0)/(Xc-Xc0)) +Xc0
+                                if Yc0 < yZero:
+                                    canvas.drawLine(Xc0, Yc0, Xcm, yZero, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                    canvas.drawLine(Xcm, yZero, Xc, yZero-(Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                else:
+                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xcm, yZero, color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                    canvas.drawLine(Xcm, yZero, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                            elif (Yc0-yZero)*(Yc-yZero) > 0:
+                                if Yc < yZero:
+                                    canvas.drawLine(Xc0, Yc0, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                else:
+                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xc, yZero - (Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                            else:
+                                minYc = min(Yc-yZero, Yc0-yZero)
+                                if minYc < 0:
+                                    canvas.drawLine(Xc0, Yc0, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                else:
+                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xc, yZero - (Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                if not self.multipleInterval and INTERCROSS and self.dominanceChecked:
+                    plusColor = self.DOMINANCE_COLOR_POSITIVE
+                    minusColor = self.DOMINANCE_COLOR_NEGATIVE
+                    for k, aPoint in enumerate(DominanceCoordXY):
+                        if k > 0:
+                            Xc0, Yc0 = DominanceCoordXY[k-1]
+                            Xc, Yc = aPoint
+                            if (Yc0-yZero)*(Yc-yZero) < 0:
+                                if Xc == Xc0: #genotype , locus distance is 0
+                                    Xcm = Xc
+                                else:	
+                                    Xcm = (yZero-Yc0)/((Yc-Yc0)/(Xc-Xc0)) +Xc0
+                                if Yc0 < yZero:
+                                    canvas.drawLine(Xc0, Yc0, Xcm, yZero, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                    canvas.drawLine(Xcm, yZero, Xc, yZero-(Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                else:
+                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xcm, yZero, color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                    canvas.drawLine(Xcm, yZero, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                            elif (Yc0-yZero)*(Yc-yZero) > 0:
+                                if Yc < yZero:
+                                    canvas.drawLine(Xc0, Yc0, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                else:
+                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xc, yZero - (Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                            else:
+                                minYc = min(Yc-yZero, Yc0-yZero)
+                                if minYc < 0:
+                                    canvas.drawLine(Xc0, Yc0, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                                else:
+                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xc, yZero - (Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
+                startPosX +=  (self.ChrLengthDistList[j]+self.GraphInterval)*plotXScale
+        
+        ###draw additive scale
+        if not self.multipleInterval and self.additiveChecked:
+            additiveScaleFont=pid.Font(ttf="verdana",size=12*fontZoom,bold=0)
+            additiveScale = Plot.detScaleOld(0,additiveMax)
+            additiveStep = (additiveScale[1]-additiveScale[0])/additiveScale[2]
+            additiveAxisList = Plot.frange(0, additiveScale[1], additiveStep)
+            maxAdd =  additiveScale[1]
+            addPlotScale = AdditiveHeightThresh/additiveMax
+            
+            additiveAxisList.append(additiveScale[1])
+            for item in additiveAxisList:
+                additiveY = yZero - item*addPlotScale
+                canvas.drawLine(xLeftOffset + plotWidth,additiveY,xLeftOffset+4+ plotWidth,additiveY,color=self.ADDITIVE_COLOR_POSITIVE, width=1*zoom)
+                scaleStr = "%2.3f" % item
+                canvas.drawString(scaleStr,xLeftOffset + plotWidth +6,additiveY+5,font=additiveScaleFont,color=self.ADDITIVE_COLOR_POSITIVE)
+            
+            canvas.drawLine(xLeftOffset+plotWidth,additiveY,xLeftOffset+plotWidth,yZero,color=self.ADDITIVE_COLOR_POSITIVE, width=1*zoom)
+        
+        canvas.drawLine(xLeftOffset, yZero, xLeftOffset, yTopOffset, color=self.LRS_COLOR, width=1*zoom)  #the blue line running up the y axis
+
+
+    def set_options(self, start_vars):
+        """Sets various options (physical/genetic mapping, # permutations, which chromosome"""
+        
+        self.plot_scale = start_vars['scale']
+        #if self.plotScale == 'physic' and not fd.genotype.Mbmap:
+        #    self.plotScale = 'morgan'
+        self.num_permutations = start_vars['num_permutations']
+        self.do_bootstrap = start_vars['do_bootstrap']
+        self.control_locus = start_vars['control_locus']
+        self.selected_chr = start_vars['selected_chr']
+
+
+    def identify_empty_samples(self):
+        no_val_samples = []
+        for sample_count, val in enumerate(self.vals):
+            if val == "x":
+                no_val_samples.append(sample_count)
+        return no_val_samples
+        
+    def trim_genotypes(self, genotype_data, no_value_samples):
+        trimmed_genotype_data = []
+        for marker in genotype_data:
+            new_genotypes = []
+            for item_count, genotype in enumerate(marker):
+                if item_count in no_value_samples:
+                    continue
+                try:
+                    genotype = float(genotype)
+                except ValueError:
+                    genotype = np.nan
+                    pass
+                new_genotypes.append(genotype)
+            trimmed_genotype_data.append(new_genotypes)
+        return trimmed_genotype_data
\ No newline at end of file
-- 
cgit v1.2.3


From 4c37e3962d6f34a935ea23511e5b760be4208474 Mon Sep 17 00:00:00 2001
From: Zachary Sloan
Date: Tue, 24 Sep 2013 14:25:28 -0500
Subject: Just committing a few additions to the interval mapping code

---
 web/webqtl/intervalMapping/IntervalMappingPage.py  |   2 +-
 .../wqflask/interval_mapping/interval_mapping.py   | 370 +++++++++------------
 2 files changed, 162 insertions(+), 210 deletions(-)

diff --git a/web/webqtl/intervalMapping/IntervalMappingPage.py b/web/webqtl/intervalMapping/IntervalMappingPage.py
index 4bdf45ab..c3ef1cbd 100755
--- a/web/webqtl/intervalMapping/IntervalMappingPage.py
+++ b/web/webqtl/intervalMapping/IntervalMappingPage.py
@@ -2038,7 +2038,7 @@ class IntervalMappingPage(templatePage):
 					qtlresult = self.genotype.regression(strains = _strains, trait = _vals)
 
 			self.qtlresults.append(qtlresult)
-		
+
 		if not self.multipleInterval:
 			if self.controlLocus and self.selectedChr > -1:
 				self.genotype.chromosome = [self.genotype[self.selectedChr]]
diff --git a/wqflask/wqflask/interval_mapping/interval_mapping.py b/wqflask/wqflask/interval_mapping/interval_mapping.py
index 3ec08f6b..48e8018e 100644
--- a/wqflask/wqflask/interval_mapping/interval_mapping.py
+++ b/wqflask/wqflask/interval_mapping/interval_mapping.py
@@ -52,7 +52,7 @@ class IntervalMapping(object):
  
         self.set_options(start_vars)
  
-        self.gen_data(tempdata)
+        self.gen_qtl_results(tempdata)
 
         #Get chromosome lengths for drawing the interval map plot
         chromosome_mb_lengths = {}
@@ -60,217 +60,11 @@ class IntervalMapping(object):
             chromosome_mb_lengths[key] = self.species.chromosomes.chromosomes[key].mb_length
         
         self.js_data = dict(
+            lrs_lod = self.lrs_lod,
             chromosomes = chromosome_mb_lengths,
             qtl_results = self.qtl_results,
         )
 
-    def get_qtl_results(self):
-        """Gets the LOD (or LRS) score at each marker in order do the qtl mapping"""
-        
-        
-        #INTERCROSS = (self.genotype.type=="intercross")
-
-        #THESE ARE OLD COMMENTS
-        #draw the LRS scale
-        #We first determine whether or not we are using a sliding scale.
-        #If so, we need to compute the maximum LRS value to determine where the max y-value should be, and call this LRSMax.
-        #LRSTop is then defined to be above the LRSMax by enough to add one additional LRSScale increment.
-        #if we are using a set-scale, then we set LRSTop to be the user's value, and LRSMax doesn't matter.
-    
-        #if self.lrs_lod == 'LOD':
-        #    lodm = self.LODFACTOR
-        #else:
-        #    lodm = 1.0
-                
-        if self.lrsMax <= 0:  #sliding scale
-            LRSMax = max(map(max, self.qtlresults)).lrs
-            #genotype trait will give infinite LRS
-            LRSMax = min(LRSMax, webqtlConfig.MAXLRS)
-            if self.permChecked and not self.multipleInterval:
-                self.significance = min(self.significance, webqtlConfig.MAXLRS)
-                self.suggestive = min(self.suggestive, webqtlConfig.MAXLRS)
-                LRSMax = max(self.significance, LRSMax)
-        else:
-            LRSMax = self.lrsMax*lodm
-            
-        if LRSMax/lodm > 100:
-            LRSScale = 20.0
-        elif LRSMax/lodm > 20:
-            LRSScale = 5.0
-        elif LRSMax/lodm > 7.5:
-            LRSScale = 2.5
-        else:
-            LRSScale = 1.0
-    
-        LRSAxisList = Plot.frange(LRSScale, LRSMax/lodm, LRSScale)
-        #make sure the user's value appears on the y-axis
-        #update by NL 6-21-2011: round the LOD value to 100 when LRSMax is equal to 460
-        LRSAxisList.append(round(LRSMax/lodm)) 
-    
-        #draw the "LRS" or "LOD" string to the left of the axis
-        LRSScaleFont=pid.Font(ttf="verdana", size=14*fontZoom, bold=0)
-        LRSLODFont=pid.Font(ttf="verdana", size=14*zoom*1.5, bold=0)
-        yZero = yTopOffset + plotHeight
-        
-    
-        canvas.drawString(self.LRS_LOD, xLeftOffset - canvas.stringWidth("999.99", font=LRSScaleFont) - 10*zoom, \
-                          yZero - 150, font=LRSLODFont, color=pid.black, angle=90)
-                        
-        for item in LRSAxisList:
-            yLRS = yZero - (item*lodm/LRSMax) * LRSHeightThresh
-            canvas.drawLine(xLeftOffset, yLRS, xLeftOffset - 4, yLRS, color=self.LRS_COLOR, width=1*zoom)
-            scaleStr = "%2.1f" % item
-            canvas.drawString(scaleStr, xLeftOffset-4-canvas.stringWidth(scaleStr, font=LRSScaleFont)-5, yLRS+3, font=LRSScaleFont, color=self.LRS_COLOR)
-    
-    
-        #"Significant" and "Suggestive" Drawing Routine
-        # ======= Draw the thick lines for "Significant" and "Suggestive" =====  (crowell: I tried to make the SNPs draw over these lines, but piddle wouldn't have it...)
-        if self.permChecked and not self.multipleInterval:
-            significantY = yZero - self.significance*LRSHeightThresh/LRSMax
-            suggestiveY = yZero - self.suggestive*LRSHeightThresh/LRSMax
-            startPosX = xLeftOffset
-            for i, _chr in enumerate(self.genotype):
-                rightEdge = int(startPosX + self.ChrLengthDistList[i]*plotXScale - self.SUGGESTIVE_WIDTH/1.5)
-                canvas.drawLine(startPosX+self.SUGGESTIVE_WIDTH/1.5, suggestiveY, rightEdge, suggestiveY, color=self.SUGGESTIVE_COLOR,
-                    width=self.SUGGESTIVE_WIDTH*zoom, clipX=(xLeftOffset, xLeftOffset + plotWidth-2))
-                canvas.drawLine(startPosX+self.SUGGESTIVE_WIDTH/1.5, significantY, rightEdge, significantY, color=self.SIGNIFICANT_COLOR, 
-                    width=self.SIGNIFICANT_WIDTH*zoom, clipX=(xLeftOffset, xLeftOffset + plotWidth-2))
-                sugg_coords = "%d, %d, %d, %d" % (startPosX, suggestiveY-2, rightEdge + 2*zoom, suggestiveY+2)
-                sig_coords = "%d, %d, %d, %d" % (startPosX, significantY-2, rightEdge + 2*zoom, significantY+2)
-                if self.LRS_LOD == 'LRS':
-                    sugg_title = "Suggestive LRS = %0.2f" % self.suggestive
-                    sig_title = "Significant LRS = %0.2f" % self.significance
-                else:
-                    sugg_title = "Suggestive LOD = %0.2f" % (self.suggestive/4.61)
-                    sig_title = "Significant LOD = %0.2f" % (self.significance/4.61)
-                Areas1 = HT.Area(shape='rect',coords=sugg_coords,title=sugg_title)
-                Areas2 = HT.Area(shape='rect',coords=sig_coords,title=sig_title)
-                gifmap.areas.append(Areas1)
-                gifmap.areas.append(Areas2)
-    
-                startPosX +=  (self.ChrLengthDistList[i]+self.GraphInterval)*plotXScale
-    
-    
-        if self.multipleInterval:
-            lrsEdgeWidth = 1
-        else:
-            additiveMax = max(map(lambda X : abs(X.additive), self.qtlresults[0]))
-            if INTERCROSS:
-                dominanceMax = max(map(lambda X : abs(X.dominance), self.qtlresults[0]))
-            else:
-                dominanceMax = -1
-            lrsEdgeWidth = 2
-        for i, qtlresult in enumerate(self.qtlresults):
-            m = 0
-            startPosX = xLeftOffset
-            thisLRSColor = self.colorCollection[i]
-            for j, _chr in enumerate(self.genotype):
-                LRSCoordXY = []
-                AdditiveCoordXY = []
-                DominanceCoordXY = []
-                for k, _locus in enumerate(_chr):
-                    if self.plotScale == 'physic':
-                        Xc = startPosX + (_locus.Mb-startMb)*plotXScale
-                    else:
-                        Xc = startPosX + (_locus.cM-_chr[0].cM)*plotXScale
-                    # updated by NL 06-18-2011: 
-                    # fix the over limit LRS graph issue since genotype trait may give infinite LRS;
-                    # for any lrs is over than 460(LRS max in this system), it will be reset to 460
-                    if 	qtlresult[m].lrs> 460 or qtlresult[m].lrs=='inf':
-                        Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRSMax
-                    else:	
-                        Yc = yZero - qtlresult[m].lrs*LRSHeightThresh/LRSMax						
-    
-                    LRSCoordXY.append((Xc, Yc))
-                    if not self.multipleInterval and self.additiveChecked:
-                        Yc = yZero - qtlresult[m].additive*AdditiveHeightThresh/additiveMax
-                        AdditiveCoordXY.append((Xc, Yc))
-                    if not self.multipleInterval and INTERCROSS and self.additiveChecked:
-                        Yc = yZero - qtlresult[m].dominance*DominanceHeightThresh/dominanceMax
-                        DominanceCoordXY.append((Xc, Yc))
-                    m += 1
-                canvas.drawPolygon(LRSCoordXY,edgeColor=thisLRSColor,closed=0, edgeWidth=lrsEdgeWidth, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                if not self.multipleInterval and self.additiveChecked:
-                    plusColor = self.ADDITIVE_COLOR_POSITIVE
-                    minusColor = self.ADDITIVE_COLOR_NEGATIVE
-                    for k, aPoint in enumerate(AdditiveCoordXY):
-                        if k > 0:
-                            Xc0, Yc0 = AdditiveCoordXY[k-1]
-                            Xc, Yc = aPoint
-                            if (Yc0-yZero)*(Yc-yZero) < 0:
-                                if Xc == Xc0: #genotype , locus distance is 0
-                                    Xcm = Xc
-                                else:	
-                                    Xcm = (yZero-Yc0)/((Yc-Yc0)/(Xc-Xc0)) +Xc0
-                                if Yc0 < yZero:
-                                    canvas.drawLine(Xc0, Yc0, Xcm, yZero, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                    canvas.drawLine(Xcm, yZero, Xc, yZero-(Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                else:
-                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xcm, yZero, color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                    canvas.drawLine(Xcm, yZero, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                            elif (Yc0-yZero)*(Yc-yZero) > 0:
-                                if Yc < yZero:
-                                    canvas.drawLine(Xc0, Yc0, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                else:
-                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xc, yZero - (Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                            else:
-                                minYc = min(Yc-yZero, Yc0-yZero)
-                                if minYc < 0:
-                                    canvas.drawLine(Xc0, Yc0, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                else:
-                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xc, yZero - (Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                if not self.multipleInterval and INTERCROSS and self.dominanceChecked:
-                    plusColor = self.DOMINANCE_COLOR_POSITIVE
-                    minusColor = self.DOMINANCE_COLOR_NEGATIVE
-                    for k, aPoint in enumerate(DominanceCoordXY):
-                        if k > 0:
-                            Xc0, Yc0 = DominanceCoordXY[k-1]
-                            Xc, Yc = aPoint
-                            if (Yc0-yZero)*(Yc-yZero) < 0:
-                                if Xc == Xc0: #genotype , locus distance is 0
-                                    Xcm = Xc
-                                else:	
-                                    Xcm = (yZero-Yc0)/((Yc-Yc0)/(Xc-Xc0)) +Xc0
-                                if Yc0 < yZero:
-                                    canvas.drawLine(Xc0, Yc0, Xcm, yZero, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                    canvas.drawLine(Xcm, yZero, Xc, yZero-(Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                else:
-                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xcm, yZero, color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                    canvas.drawLine(Xcm, yZero, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                            elif (Yc0-yZero)*(Yc-yZero) > 0:
-                                if Yc < yZero:
-                                    canvas.drawLine(Xc0, Yc0, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                else:
-                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xc, yZero - (Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                            else:
-                                minYc = min(Yc-yZero, Yc0-yZero)
-                                if minYc < 0:
-                                    canvas.drawLine(Xc0, Yc0, Xc, Yc, color=plusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                                else:
-                                    canvas.drawLine(Xc0, yZero - (Yc0-yZero), Xc, yZero - (Yc-yZero), color=minusColor, width=1, clipX=(xLeftOffset, xLeftOffset + plotWidth))
-                startPosX +=  (self.ChrLengthDistList[j]+self.GraphInterval)*plotXScale
-        
-        ###draw additive scale
-        if not self.multipleInterval and self.additiveChecked:
-            additiveScaleFont=pid.Font(ttf="verdana",size=12*fontZoom,bold=0)
-            additiveScale = Plot.detScaleOld(0,additiveMax)
-            additiveStep = (additiveScale[1]-additiveScale[0])/additiveScale[2]
-            additiveAxisList = Plot.frange(0, additiveScale[1], additiveStep)
-            maxAdd =  additiveScale[1]
-            addPlotScale = AdditiveHeightThresh/additiveMax
-            
-            additiveAxisList.append(additiveScale[1])
-            for item in additiveAxisList:
-                additiveY = yZero - item*addPlotScale
-                canvas.drawLine(xLeftOffset + plotWidth,additiveY,xLeftOffset+4+ plotWidth,additiveY,color=self.ADDITIVE_COLOR_POSITIVE, width=1*zoom)
-                scaleStr = "%2.3f" % item
-                canvas.drawString(scaleStr,xLeftOffset + plotWidth +6,additiveY+5,font=additiveScaleFont,color=self.ADDITIVE_COLOR_POSITIVE)
-            
-            canvas.drawLine(xLeftOffset+plotWidth,additiveY,xLeftOffset+plotWidth,yZero,color=self.ADDITIVE_COLOR_POSITIVE, width=1*zoom)
-        
-        canvas.drawLine(xLeftOffset, yZero, xLeftOffset, yTopOffset, color=self.LRS_COLOR, width=1*zoom)  #the blue line running up the y axis
-
-
     def set_options(self, start_vars):
         """Sets various options (physical/genetic mapping, # permutations, which chromosome"""
         
@@ -281,6 +75,38 @@ class IntervalMapping(object):
         self.do_bootstrap = start_vars['do_bootstrap']
         self.control_locus = start_vars['control_locus']
         self.selected_chr = start_vars['selected_chr']
+        self.weighted_regression = start_vars['weighted']
+        self.lrs_lod = start_vars['lrs_lod']
+
+
+    def gen_qtl_results(self, tempdata):
+        """Generates qtl results for plotting interval map"""
+
+        self.dataset.group.get_markers()
+
+        pheno_vector = np.array([val == "x" and np.nan or float(val) for val in self.vals])
+
+        #if self.dataset.group.species == "human":
+        #    p_values, t_stats = self.gen_human_results(pheno_vector, tempdata)
+        #else:
+        genotype_data = [marker['genotypes'] for marker in self.dataset.group.markers.markers]
+        
+        no_val_samples = self.identify_empty_samples()
+        trimmed_genotype_data = self.trim_genotypes(genotype_data, no_val_samples)
+        
+        genotype_matrix = np.array(trimmed_genotype_data).T
+        
+        t_stats, p_values = lmm.run(
+            pheno_vector,
+            genotype_matrix,
+            restricted_max_likelihood=True,
+            refit=False,
+            temp_data=tempdata
+        )
+        
+        self.dataset.group.markers.add_pvalues(p_values)
+        
+        self.qtl_results = self.dataset.group.markers.markers
 
 
     def identify_empty_samples(self):
@@ -290,6 +116,7 @@ class IntervalMapping(object):
                 no_val_samples.append(sample_count)
         return no_val_samples
         
+        
     def trim_genotypes(self, genotype_data, no_value_samples):
         trimmed_genotype_data = []
         for marker in genotype_data:
@@ -304,4 +131,129 @@ class IntervalMapping(object):
                     pass
                 new_genotypes.append(genotype)
             trimmed_genotype_data.append(new_genotypes)
-        return trimmed_genotype_data
\ No newline at end of file
+        return trimmed_genotype_data
+
+    #def get_qtl_results(self):
+    #    """Gets the LOD (or LRS) score at each marker in order do the qtl mapping"""
+    #
+    #    
+    #    
+    #    #self.genotype = self.genotype.addinterval()
+    #    #resultSlice = []
+    #    #controlGeno = []
+    #    
+    #    #if self.multipleInterval:
+    #    #    self.suggestive = 0
+    #    #    self.significance = 0
+    #    #    if self.selectedChr > -1:
+    #    #        self.genotype.chromosome = [self.genotype[self.selectedChr]]
+    #    #else:
+    #    #single interval mapping
+    #    #try:
+    #    #    self.suggestive = float(fd.formdata.getvalue('permSuggestive'))
+    #    #    self.significance = float(fd.formdata.getvalue('permSignificance'))
+    #    #except:
+    #    #    self.suggestive = None
+    #    #    self.significance = None
+    #    
+    #    #NOT DOING MULTIPLE TRAITS YET, BUT WILL NEED TO LATER
+    #    #_strains, _vals, _vars = self.traitList[0].exportInformative(weightedRegression)
+    #    
+    #    #if webqtlUtil.ListNotNull(_vars):
+    #    #    pass
+    #    #else:
+    #    #    weightedRegression = 0
+    #    #    _strains, _vals, _vars = self.traitList[0].exportInformative()
+    #        
+    #    ##locate genotype of control Locus
+    #    #if self.controlLocus:
+    #    #    controlGeno2 = []
+    #    #    _FIND = 0
+    #    #    for _chr in self.genotype:
+    #    #        for _locus in _chr:
+    #    #            if _locus.name == self.controlLocus:
+    #    #                controlGeno2 = _locus.genotype
+    #    #                _FIND = 1
+    #    #                break
+    #    #        if _FIND:
+    #    #            break
+    #    #    if controlGeno2:
+    #    #        _prgy = list(self.genotype.prgy)
+    #    #        for _strain in _strains:
+    #    #            _idx = _prgy.index(_strain)
+    #    #            controlGeno.append(controlGeno2[_idx])
+    #    #    else:
+    #    #        return "The control marker you selected is not in the genofile."
+    #    #
+    #    #    
+    #    #    if self.significance and self.suggestive:
+    #    #        pass
+    #    #    else:
+    #    #        if self.permChecked:
+    #    #            if weightedRegression:
+    #    #                self.LRSArray = self.genotype.permutation(strains = _strains, trait = _vals, 
+    #    #                    variance = _vars, nperm=fd.nperm)
+    #    #            else:
+    #    #                self.LRSArray = self.genotype.permutation(strains = _strains, trait = _vals, 
+    #    #                    nperm=fd.nperm)
+    #    #            self.suggestive = self.LRSArray[int(fd.nperm*0.37-1)]
+    #    #            self.significance = self.LRSArray[int(fd.nperm*0.95-1)]
+    #    #
+    #    #        else:
+    #    #            self.suggestive = 9.2
+    #    #            self.significance = 16.1
+    #    #
+    #    #    #calculating bootstrap
+    #    #    #from now on, genotype could only contain a single chromosome 
+    #    #    #permutation need to be performed genome wide, this is not the case for bootstrap
+    #    #    
+    #    #    #due to the design of qtlreaper, composite regression need to be performed genome wide
+    #    #    if not self.controlLocus and self.selectedChr > -1:
+    #    #        self.genotype.chromosome = [self.genotype[self.selectedChr]]
+    #    #    elif self.selectedChr > -1: #self.controlLocus and self.selectedChr > -1
+    #    #        lociPerChr = map(len, self.genotype)
+    #    #        resultSlice = reduce(lambda X, Y: X+Y, lociPerChr[:self.selectedChr], 0)
+    #    #        resultSlice = [resultSlice,resultSlice+lociPerChr[self.selectedChr]]
+    #    #    else:
+    #    #        pass
+    #        
+    #    #calculate QTL for each trait
+    #    self.qtl_results = []
+    #
+    #    #for thisTrait in self.traitList:
+    #    _strains, _vals, _vars = thisTrait.exportInformative(weightedRegression)
+    #    if self.controlLocus:
+    #        if weightedRegression:
+    #            qtlresult = self.genotype.regression(strains = _strains, trait = _vals, 
+    #                    variance = _vars, control = self.controlLocus)
+    #        else:
+    #            qtlresult = self.genotype.regression(strains = _strains, trait = _vals,
+    #                control = self.controlLocus)
+    #        if resultSlice:
+    #            qtlresult = qtlresult[resultSlice[0]:resultSlice[1]]
+    #    else:
+    #        if weightedRegression:
+    #            qtlresult = self.genotype.regression(strains = _strains, trait = _vals, 
+    #                    variance = _vars)
+    #        else:
+    #            qtlresult = self.genotype.regression(strains = _strains, trait = _vals)
+    #
+    #    self.qtlresults.append(qtlresult)
+    #    
+    #    if not self.multipleInterval:
+    #        if self.controlLocus and self.selectedChr > -1:
+    #            self.genotype.chromosome = [self.genotype[self.selectedChr]]
+    #            
+    #        if self.bootChecked:
+    #            if controlGeno:
+    #                self.bootResult = self.genotype.bootstrap(strains = _strains, trait = _vals,
+    #                    control = controlGeno, nboot=fd.nboot)
+    #            elif weightedRegression:
+    #                self.bootResult = self.genotype.bootstrap(strains = _strains, trait = _vals, 
+    #                    variance = _vars, nboot=fd.nboot)
+    #            else:
+    #                self.bootResult = self.genotype.bootstrap(strains = _strains, trait = _vals, 
+    #                    nboot=fd.nboot)
+    #        else:
+    #            self.bootResult = []
+
-- 
cgit v1.2.3


From 3325184b1dd310619626dd31852ab84cae6dc7fc Mon Sep 17 00:00:00 2001
From: Zachary Sloan
Date: Tue, 8 Oct 2013 12:13:56 -0500
Subject: Did some work with interval mapping page; will use qtl reaper to do
 the mapping, since it is reliable/fast and avoids us having to rewrite from
 scratch using something like r/qtl

---
 wqflask/base/data_set.py                           | 20 ++++----
 wqflask/maintenance/quick_search_table.py          |  4 +-
 .../wqflask/interval_mapping/interval_mapping.py   | 53 ++++++++++++++++++++++
 3 files changed, 67 insertions(+), 10 deletions(-)

diff --git a/wqflask/base/data_set.py b/wqflask/base/data_set.py
index 96e04df0..befbd518 100755
--- a/wqflask/base/data_set.py
+++ b/wqflask/base/data_set.py
@@ -168,13 +168,13 @@ class Markers(object):
         
         for marker, p_value in itertools.izip(self.markers, p_values):
             marker['p_value'] = p_value
-            if marker['p_value'] == 0:
-                marker['lod_score'] = 0
-                marker['lrs_value'] = 0
-            else:
-                marker['lod_score'] = -math.log10(marker['p_value'])
-                #Using -log(p) for the LRS; need to ask Rob how he wants to get LRS from p-values
-                marker['lrs_value'] = -math.log10(marker['p_value']) * 4.61
+            if math.isnan(marker['p_value']):
+                print("p_value is:", marker['p_value'])
+            marker['lod_score'] = -math.log10(marker['p_value'])
+            #Using -log(p) for the LRS; need to ask Rob how he wants to get LRS from p-values
+            marker['lrs_value'] = -math.log10(marker['p_value']) * 4.61
+        
+        
 
 
 class HumanMarkers(Markers):
@@ -189,6 +189,8 @@ class HumanMarkers(Markers):
             marker['name'] = splat[1]
             marker['Mb'] = float(splat[3]) / 1000000
             self.markers.append(marker)
+            
+        #print("markers is: ", pf(self.markers))
 
 
     def add_pvalues(self, p_values):
@@ -315,10 +317,10 @@ class DatasetGroup(object):
 
         #determine default genotype object
         if self.incparentsf1 and genotype_1.type != "intercross":
-            genotype = genotype_2
+            self.genotype = genotype_2
         else:
             self.incparentsf1 = 0
-            genotype = genotype_1
+            self.genotype = genotype_1
 
         self.samplelist = list(genotype.prgy)
 
diff --git a/wqflask/maintenance/quick_search_table.py b/wqflask/maintenance/quick_search_table.py
index 9cd792ef..23bd505c 100644
--- a/wqflask/maintenance/quick_search_table.py
+++ b/wqflask/maintenance/quick_search_table.py
@@ -11,8 +11,10 @@ each trait, its dataset, and several columns determined by its trait type (pheno
 
 """
 
-from __future__ import print_function, division, absolute_import
+from __future__ import absolute_import, division, print_function
 
+# We do this here so we can use zach_settings
+# Not to avoid other absoulte_imports
 import sys
 sys.path.append("../../..")
 
diff --git a/wqflask/wqflask/interval_mapping/interval_mapping.py b/wqflask/wqflask/interval_mapping/interval_mapping.py
index 48e8018e..5d660224 100644
--- a/wqflask/wqflask/interval_mapping/interval_mapping.py
+++ b/wqflask/wqflask/interval_mapping/interval_mapping.py
@@ -12,6 +12,7 @@ import collections
 
 import numpy as np
 from scipy import linalg
+import rpy2.robjects
 
 import simplejson as json
 
@@ -83,6 +84,28 @@ class IntervalMapping(object):
         """Generates qtl results for plotting interval map"""
 
         self.dataset.group.get_markers()
+        self.dataset.read_genotype_file()
+
+        samples, values, variances = self.trait.export_informative()
+        if self.control_locus:
+            if self.weighted_regression:
+                qtl_result = self.dataset.genotype.regression(strains = samples,
+                                                              trait = values,
+                                                              variance = variances,
+                                                              control = self.control_locus)
+            else:
+                qtl_result = self.dataset.genotype.regression(strains = samples,
+                                                              trait = values,
+                                                              control = self.control_locus)
+        else:
+            if self.weighted_regression:
+                qtl_result = self.dataset.genotype.regression(strains = samples,
+                                                              trait = values,
+                                                              variance = variances)
+            else:
+                qtl_result = self.dataset.genotype.regression(strains = samples,
+                                                              trait = values)
+
 
         pheno_vector = np.array([val == "x" and np.nan or float(val) for val in self.vals])
 
@@ -108,6 +131,36 @@ class IntervalMapping(object):
         
         self.qtl_results = self.dataset.group.markers.markers
 
+    #def gen_qtl_results_2(self, tempdata):
+    #    """Generates qtl results for plotting interval map"""
+    #
+    #    self.dataset.group.get_markers()
+    #    self.dataset.read_genotype_file()
+    #
+    #    pheno_vector = np.array([val == "x" and np.nan or float(val) for val in self.vals])
+    #
+    #    #if self.dataset.group.species == "human":
+    #    #    p_values, t_stats = self.gen_human_results(pheno_vector, tempdata)
+    #    #else:
+    #    genotype_data = [marker['genotypes'] for marker in self.dataset.group.markers.markers]
+    #    
+    #    no_val_samples = self.identify_empty_samples()
+    #    trimmed_genotype_data = self.trim_genotypes(genotype_data, no_val_samples)
+    #    
+    #    genotype_matrix = np.array(trimmed_genotype_data).T
+    #    
+    #    t_stats, p_values = lmm.run(
+    #        pheno_vector,
+    #        genotype_matrix,
+    #        restricted_max_likelihood=True,
+    #        refit=False,
+    #        temp_data=tempdata
+    #    )
+    #    
+    #    self.dataset.group.markers.add_pvalues(p_values)
+    #    
+    #    self.qtl_results = self.dataset.group.markers.markers
+
 
     def identify_empty_samples(self):
         no_val_samples = []
-- 
cgit v1.2.3


From a823e66f8dc742e1608b3e0db6d521d5f63b641a Mon Sep 17 00:00:00 2001
From: Zachary Sloan
Date: Tue, 15 Oct 2013 15:06:36 -0500
Subject: Changed templates to call the header macro

Correlation page now works with Non-BXD (or whatever group)
or All Samples options
---
 wqflask/base/data_set.py                          | 14 ++++++++------
 wqflask/wqflask/correlation/show_corr_results.py  |  4 ++--
 wqflask/wqflask/templates/base.html               |  4 ++--
 wqflask/wqflask/templates/correlation_page.html   |  8 ++------
 wqflask/wqflask/templates/index_page.html         |  2 --
 wqflask/wqflask/templates/marker_regression.html  | 10 ++--------
 wqflask/wqflask/templates/quick_search.html       | 11 +++--------
 wqflask/wqflask/templates/search_result_page.html | 10 ++--------
 wqflask/wqflask/templates/show_trait.html         | 11 +++--------
 9 files changed, 24 insertions(+), 50 deletions(-)

diff --git a/wqflask/base/data_set.py b/wqflask/base/data_set.py
index 9fa7beb3..f25e7974 100755
--- a/wqflask/base/data_set.py
+++ b/wqflask/base/data_set.py
@@ -322,7 +322,7 @@ class DatasetGroup(object):
             self.incparentsf1 = 0
             self.genotype = genotype_1
 
-        self.samplelist = list(genotype.prgy)
+        self.samplelist = list(self.genotype.prgy)
 
 
 #class DataSets(object):
@@ -440,10 +440,12 @@ class DataSet(object):
         
     def get_trait_data(self, sample_list=None):
         if sample_list:
-            self.samplelist = sample_list + self.group.parlist + self.group.f1list
+            self.samplelist = sample_list
         else:
-            self.samplelist = self.group.samplelist + self.group.parlist + self.group.f1list
-        
+            self.samplelist = self.group.samplelist
+            
+        if (self.group.parlist + self.group.f1list) in self.samplelist:
+            self.samplelist += self.group.parlist + self.group.f1list
         
         query = """
             SELECT Strain.Name, Strain.Id FROM Strain, Species
@@ -503,8 +505,8 @@ class DataSet(object):
                         and {}Freeze.Name = '{}'
                         and {}.Id = {}XRef.{}Id
                         order by {}.Id
-                        """.format(*mescape(self.type, self.type, self.type, self.type,
-                                   self.name, dataset_type, self.type, self.type, dataset_type))
+                        """.format(*mescape(self.type, self.type, self.type, self.name, 
+                                    dataset_type, self.type, dataset_type, dataset_type))
             else:
                 query += """
                         WHERE {}XRef.{}FreezeId = {}Freeze.Id
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index a5c80674..8f23165c 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -178,10 +178,10 @@ class CorrelationResults(object):
                     trait_object.lit_corr = lit_corr_data[trait][1]
                 self.correlation_results.append(trait_object)
             
-            if self.corr_type != "lit":
+            if self.corr_type != "lit" and self.dataset.type == "ProbeSet":
                 self.do_lit_correlation_for_trait_list()
             
-            if self.corr_type != "tissue":
+            if self.corr_type != "tissue" and self.dataset.type == "ProbeSet":
                 self.do_tissue_correlation_for_trait_list()
             
             #print("self.correlation_results: ", pf(self.correlation_results))
diff --git a/wqflask/wqflask/templates/base.html b/wqflask/wqflask/templates/base.html
index 8efba6a7..a14eeb44 100644
--- a/wqflask/wqflask/templates/base.html
+++ b/wqflask/wqflask/templates/base.html
@@ -29,9 +29,9 @@
 {% macro header(main, second) %}
     <header class="jumbotron subhead" id="overview">
         <div class="container">
-            <h1>Login</h1>
+            <h1>{{ main }}</h1>
             <p class="lead">
-               Gain access to GeneNetwork.
+               {{ second }}
             </p>               
         </div>
     </header>
diff --git a/wqflask/wqflask/templates/correlation_page.html b/wqflask/wqflask/templates/correlation_page.html
index 4d09cf20..7e149506 100644
--- a/wqflask/wqflask/templates/correlation_page.html
+++ b/wqflask/wqflask/templates/correlation_page.html
@@ -6,12 +6,8 @@
     <link rel="stylesheet" type="text/css" href="/static/packages/TableTools/media/css/TableTools.css" />
 {% endblock %}
 {% block content %}
-
-    <header class="jumbotron subhead" id="overview">
-        <div class="container">
-            <h1>Correlation</h1>
-        </div>
-    </header>
+    
+    {{ header("Correlation", 'Trait: {} Dataset: {}'.format(this_trait.name, dataset.name)) }}
 
     <table id="corr_results" class="table table-hover table-striped table-bordered">
         <thead>
diff --git a/wqflask/wqflask/templates/index_page.html b/wqflask/wqflask/templates/index_page.html
index 98682e57..d177a7bd 100644
--- a/wqflask/wqflask/templates/index_page.html
+++ b/wqflask/wqflask/templates/index_page.html
@@ -3,8 +3,6 @@
 {% block content %}
 <!-- Start of body -->
 
-
-
     <header class="jumbotron subhead" id="overview">
         <div class="container">
             <h1>GeneNetwork</h1>
diff --git a/wqflask/wqflask/templates/marker_regression.html b/wqflask/wqflask/templates/marker_regression.html
index 9260acab..64d2e9b7 100644
--- a/wqflask/wqflask/templates/marker_regression.html
+++ b/wqflask/wqflask/templates/marker_regression.html
@@ -9,14 +9,8 @@
 {% endblock %}
 {% block content %} <!-- Start of body -->
 
-    <header class="jumbotron subhead" id="overview">
-        <div class="container">
-            <h1>Marker Regression</h1>
-            <p class="lead">
-                {{ this_trait.name }}: {{ this_trait.description_fmt }}
-            </p>
-        </div>
-    </header>
+    {{ header("Marker Regression",
+        '{}: {}'.format(this_trait.name, this_trait.description_fmt)) }}
 
     <div class="container">
         <div>
diff --git a/wqflask/wqflask/templates/quick_search.html b/wqflask/wqflask/templates/quick_search.html
index b0e38708..2f268c5a 100644
--- a/wqflask/wqflask/templates/quick_search.html
+++ b/wqflask/wqflask/templates/quick_search.html
@@ -2,14 +2,9 @@
 {% block title %}QuickSearch Results{% endblock %}
 {% block content %}
 <!-- Start of body -->
-    <header class="jumbotron subhead" id="overview">
-        <div class="container">
-            <h1>QuickSearch Results</h1>
-            <p class="lead">
-                GeneNetwork found {{ numify(results|count, "record", "records") }}.
-            </p>
-        </div>
-    </header>
+
+    {{ header("QuickSearch Results",
+        'GeneNetwork found {}.'.format(numify(results|count, "record", "records"))) }}
 
     <div class="container">
         <div class="page-header">
diff --git a/wqflask/wqflask/templates/search_result_page.html b/wqflask/wqflask/templates/search_result_page.html
index 11f68bba..1fe7cce9 100644
--- a/wqflask/wqflask/templates/search_result_page.html
+++ b/wqflask/wqflask/templates/search_result_page.html
@@ -2,14 +2,8 @@
 {% block title %}Search Results{% endblock %}
 {% block content %}
 <!-- Start of body -->
-    <header class="jumbotron subhead" id="overview">
-        <div class="container">
-            <h1>Search Results</h1>
-            <p class="lead">
-                GeneNetwork found {{ numify(results|count, "record", "records") }}.
-            </p>
-        </div>
-    </header>
+    {{ header("Search Results",
+        'GeneNetwork found {}.'.format(numify(results|count, "record", "records"))) }}
 
     <div class="container">
         <div class="page-header">
diff --git a/wqflask/wqflask/templates/show_trait.html b/wqflask/wqflask/templates/show_trait.html
index 799245c3..e3c84de7 100644
--- a/wqflask/wqflask/templates/show_trait.html
+++ b/wqflask/wqflask/templates/show_trait.html
@@ -7,14 +7,9 @@
 {% endblock %}
 {% block content %} <!-- Start of body -->
 
-    <header class="jumbotron subhead" id="overview">
-        <div class="container">
-            <h1>{{ this_trait.symbol}}</h1>
-            <p class="lead">
-                {{ this_trait.name }}: {{ this_trait.description_fmt }}
-            </p>
-        </div>
-    </header>
+    {{ header("{}".format(this_trait.symbol),
+        '{}: {}'.format(this_trait.name, this_trait.description_fmt)) }}
+
 
     <form method="post" action="/corr_compute" name="trait_page" id="trait_data_form"
     class="form-horizontal">
-- 
cgit v1.2.3


From da0526b9d870ba937fcf860c40731c9d96eb9f63 Mon Sep 17 00:00:00 2001
From: Zachary Sloan
Date: Wed, 16 Oct 2013 18:02:28 -0500
Subject: Added interval_mapping to views.py

Made some more changes to interval_mapping.py
---
 misc/notes.txt                                     |  3 +
 .../wqflask/interval_mapping/interval_mapping.py   | 70 +++++++++++-----------
 wqflask/wqflask/views.py                           | 44 ++++++++++++++
 3 files changed, 82 insertions(+), 35 deletions(-)
 mode change 100644 => 100755 wqflask/wqflask/interval_mapping/interval_mapping.py

diff --git a/misc/notes.txt b/misc/notes.txt
index 91a0e67c..f6a2bb33 100644
--- a/misc/notes.txt
+++ b/misc/notes.txt
@@ -90,6 +90,9 @@ Reload web server:
 Run server:
 python runserver.py
 
+Run sendmail.py
+python send_mail.py
+
 ===========================================
 
 UFW - default firewall confirguation tool for Ubuntu; eases iptables firewall configuration
diff --git a/wqflask/wqflask/interval_mapping/interval_mapping.py b/wqflask/wqflask/interval_mapping/interval_mapping.py
old mode 100644
new mode 100755
index 5d660224..aca99cbe
--- a/wqflask/wqflask/interval_mapping/interval_mapping.py
+++ b/wqflask/wqflask/interval_mapping/interval_mapping.py
@@ -89,26 +89,56 @@ class IntervalMapping(object):
         samples, values, variances = self.trait.export_informative()
         if self.control_locus:
             if self.weighted_regression:
-                qtl_result = self.dataset.genotype.regression(strains = samples,
+                self.qtl_results = self.dataset.genotype.regression(strains = samples,
                                                               trait = values,
                                                               variance = variances,
                                                               control = self.control_locus)
             else:
-                qtl_result = self.dataset.genotype.regression(strains = samples,
+                self.qtl_results = self.dataset.genotype.regression(strains = samples,
                                                               trait = values,
                                                               control = self.control_locus)
         else:
             if self.weighted_regression:
-                qtl_result = self.dataset.genotype.regression(strains = samples,
+                self.qtl_results = self.dataset.genotype.regression(strains = samples,
                                                               trait = values,
                                                               variance = variances)
             else:
-                qtl_result = self.dataset.genotype.regression(strains = samples,
+                self.qtl_results = self.dataset.genotype.regression(strains = samples,
                                                               trait = values)
 
 
-        pheno_vector = np.array([val == "x" and np.nan or float(val) for val in self.vals])
+        #pheno_vector = np.array([val == "x" and np.nan or float(val) for val in self.vals])
+
+        #if self.dataset.group.species == "human":
+        #    p_values, t_stats = self.gen_human_results(pheno_vector, tempdata)
+        #else:
+        genotype_data = [marker['genotypes'] for marker in self.dataset.group.markers.markers]
+        
+        no_val_samples = self.identify_empty_samples()
+        trimmed_genotype_data = self.trim_genotypes(genotype_data, no_val_samples)
+        
+        genotype_matrix = np.array(trimmed_genotype_data).T
+        
+        #t_stats, p_values = lmm.run(
+        #    pheno_vector,
+        #    genotype_matrix,
+        #    restricted_max_likelihood=True,
+        #    refit=False,
+        #    temp_data=tempdata
+        #)
+        
+        #self.dataset.group.markers.add_pvalues(p_values)
+        
+        #self.qtl_results = self.dataset.group.markers.markers
 
+    def gen_qtl_results_2(self, tempdata):
+        """Generates qtl results for plotting interval map"""
+    
+        self.dataset.group.get_markers()
+        self.dataset.read_genotype_file()
+    
+        pheno_vector = np.array([val == "x" and np.nan or float(val) for val in self.vals])
+    
         #if self.dataset.group.species == "human":
         #    p_values, t_stats = self.gen_human_results(pheno_vector, tempdata)
         #else:
@@ -131,36 +161,6 @@ class IntervalMapping(object):
         
         self.qtl_results = self.dataset.group.markers.markers
 
-    #def gen_qtl_results_2(self, tempdata):
-    #    """Generates qtl results for plotting interval map"""
-    #
-    #    self.dataset.group.get_markers()
-    #    self.dataset.read_genotype_file()
-    #
-    #    pheno_vector = np.array([val == "x" and np.nan or float(val) for val in self.vals])
-    #
-    #    #if self.dataset.group.species == "human":
-    #    #    p_values, t_stats = self.gen_human_results(pheno_vector, tempdata)
-    #    #else:
-    #    genotype_data = [marker['genotypes'] for marker in self.dataset.group.markers.markers]
-    #    
-    #    no_val_samples = self.identify_empty_samples()
-    #    trimmed_genotype_data = self.trim_genotypes(genotype_data, no_val_samples)
-    #    
-    #    genotype_matrix = np.array(trimmed_genotype_data).T
-    #    
-    #    t_stats, p_values = lmm.run(
-    #        pheno_vector,
-    #        genotype_matrix,
-    #        restricted_max_likelihood=True,
-    #        refit=False,
-    #        temp_data=tempdata
-    #    )
-    #    
-    #    self.dataset.group.markers.add_pvalues(p_values)
-    #    
-    #    self.qtl_results = self.dataset.group.markers.markers
-
 
     def identify_empty_samples(self):
         no_val_samples = []
diff --git a/wqflask/wqflask/views.py b/wqflask/wqflask/views.py
index deccf459..29f7f150 100644
--- a/wqflask/wqflask/views.py
+++ b/wqflask/wqflask/views.py
@@ -32,6 +32,7 @@ from base.data_set import create_datasets_list
 from wqflask.show_trait import show_trait
 from wqflask.show_trait import export_trait_data
 from wqflask.marker_regression import marker_regression
+from wqflask.interval_mapping import interval_mapping
 from wqflask.correlation import show_corr_results
 from utility import temp_data
 
@@ -246,6 +247,49 @@ def marker_regression_page():
 
     return rendered_template
 
+@app.route("/interval_mapping", methods=('POST',))
+def interval_mapping_page():
+    initial_start_vars = request.form
+    temp_uuid = initial_start_vars['temp_uuid']
+    wanted = (
+        'trait_id',
+        'dataset',
+        'suggestive'
+    )
+
+    start_vars = {}
+    for key, value in initial_start_vars.iteritems():
+        if key in wanted or key.startswith(('value:')):
+            start_vars[key] = value
+
+    version = "v1"
+    key = "interval_mapping:{}:".format(version) + json.dumps(start_vars, sort_keys=True)
+    print("key is:", pf(key))
+    with Bench("Loading cache"):
+        result = Redis.get(key)
+
+    if result:
+        print("Cache hit!!!")
+        with Bench("Loading results"):
+            result = pickle.loads(result)
+    else:
+        print("Cache miss!!!")
+        template_vars = interval_mapping.IntervalMapping(start_vars, temp_uuid)
+
+        template_vars.js_data = json.dumps(template_vars.js_data,
+                                           default=json_default_handler,
+                                           indent="   ")
+
+        result = template_vars.__dict__
+        
+        #causeerror
+        Redis.set(key, pickle.dumps(result, pickle.HIGHEST_PROTOCOL))
+        Redis.expire(key, 60*60)
+
+    with Bench("Rendering template"):
+        rendered_template = render_template("interval_mapping.html", **result)
+
+    return rendered_template
 
 @app.route("/corr_compute", methods=('POST',))
 def corr_compute_page():
-- 
cgit v1.2.3