gwaslab 3.4.49__py3-none-any.whl → 3.5.1__py3-none-any.whl

gwaslab/viz_aux_annotate_plot.py

@@ -38,6 +38,7 @@ def annotate_single(
     region,
     region_anno_bbox_args,
     skip,
+    arrow_kwargs=None,
     anno_height=1,
     amode="int",
     snpid="SNPID",
@@ -48,6 +49,9 @@ def annotate_single(
     _invert=False,
     log=Log()
 ):
+    if arrow_kwargs is None:
+        arrow_kwargs=dict()
+        
     if anno and (to_annotate.empty is not True):
         #initiate a list for text and a starting position
         text = []
@@ -60,21 +64,21 @@ def annotate_single(
         elif anno:
                 annotation_col=anno
         log.write(" -Annotating using column "+annotation_col+"...", verbose=verbose)
-        
+        ################################################################################################################################
         ## calculate y span
         if region is not None:
             y_span = region[2] - region[1]
         else:
             y_span = sumstats["i"].max()-sumstats["i"].min()
-        
         log.write(" -Adjusting text positions with repel_force={}...".format(repel_force), verbose=verbose)
         if anno_style == "expand" :
             to_annotate.loc[:, "ADJUSTED_i"] = adjust_text_position(to_annotate["i"].values.copy(), y_span, repel_force,max_iter=anno_max_iter,log=log,amode=amode,verbose=verbose)
         ##  iterate through variants to be annotated
+        ################################################################################################################################
+
         anno_to_adjust_list = list()
         
         for rowi,row in to_annotate.iterrows():
-            
             # avoid text overlapping
             ## adjust x to avoid overlapping################################################################
             if anno_style == "right" :
@@ -93,7 +97,7 @@ def annotate_single(
             else:
                 pass
             ################################################################
-            #shrink or increase the arm
+            # shrink or increase the arm by a factor (arm_scale)
             if arm_scale_d is not None:
                 if anno_count not in arm_scale_d.keys():
                     arm_scale =1
@@ -102,20 +106,32 @@ def annotate_single(
             ################################################################
 
             # vertical arm length in pixels
-            #to_annotate["scaled_P"] = to_annotate5["scaled_P_2"].copy()
-            # arm length in pixels
-            #armB_length_in_point = ax1.transData.transform((skip,1.15*maxy))[1]-ax1.transData.transform((skip, row["scaled_P"]+1))[1]-arm_offset/2
-            armB_length_in_point = ax1.transData.transform((skip,1.15*maxy))[1]-ax1.transData.transform((skip, row["scaled_P"]+0.01*maxy))[1]-arm_offset/2
-            # scale if needed
-            armB_length_in_point = armB_length_in_point*arm_scale
+            # Annotation y : 1.15 * maxy_anno
+            # Top dot:  1 * maxy_anno
+            # armB_length_in_point_raw = 0.15 * maxy_anno -> gap_pixel
+            # Fixed Offset: 0.5 * 0.15 * gap_pixel
+
+            #Calculate armB length in pixels
+            # arm_scale: raise up the ceiling
+            
+            # gap : 0.5* space between top variant and annotation text
+            gap_pixel =                (ax1.transData.transform((0,1.15*maxy*arm_scale))[1]-ax1.transData.transform((0, maxy*arm_scale))[1])*0.5
+
+            # armB_length_in_pixel_raw : distance between variant to annotate and annotation text
+            armB_length_in_pixel_raw =  ax1.transData.transform((0,1.15*maxy*arm_scale))[1]-ax1.transData.transform((0, row["scaled_P"]+1))[1] 
+            
+            armB_length_in_pixel = armB_length_in_pixel_raw - gap_pixel
+
             ################################################################
+            # armB_length_in_pixel should not be negative
             if arm_scale>=1:
-                #armB_length_in_point= armB_length_in_point if armB_length_in_point>0 else ax1.transData.transform((skip, maxy+2))[1]-ax1.transData.transform((skip,  row["scaled_P"]+1))[1] 
-                armB_length_in_point= armB_length_in_point if armB_length_in_point>0 else ax1.transData.transform((skip, maxy+0.02*maxy))[1]-ax1.transData.transform((skip,  row["scaled_P"]+0.01*maxy))[1] 
-            ###if anno_fixed_arm_length #############################################################
+                armB_length_in_pixel = max(0, armB_length_in_pixel)
+            
+            ################################################################
+            #if setting anno_fixed_arm_length 
             if anno_fixed_arm_length is not None:
-                anno_fixed_arm_length_factor = ax1.transData.transform((skip,anno_fixed_arm_length))[1]-ax1.transData.transform((skip,0))[1] 
-                armB_length_in_point = anno_fixed_arm_length_factor
+                armB_length_in_pixel = ax1.transData.transform((skip,anno_fixed_arm_length))[1]-ax1.transData.transform((skip,0))[1] 
+            
             ################################################################################################################################
             # annotation alias
             if anno==True:
@@ -129,26 +145,31 @@ def annotate_single(
                 else:
                     annotation_text=row["Annotation"]
             
-            
-            #xy=(row["i"],row["scaled_P"]+0.2)
+            ################################################################################################################################
+            # setting arrow xy and text xy
+            # add a small space between variant and arrow head
             xy=(row["i"],row["scaled_P"]+0.01*maxy)
-            xytext=(last_pos,1.15*maxy*arm_scale*anno_height)
+
+            # text xy is of the same height
+            # anno_height can be used to adjust the height of annotation text
+            xytext=(last_pos,1.15*maxy*(arm_scale + anno_height -1))
             
+            # for anno_fixed_arm_length
             if anno_fixed_arm_length is not None:
-                armB_length_in_point = anno_fixed_arm_length
-                xytext=(row["i"],row["scaled_P"]+0.2+anno_fixed_arm_length)
-            
+                xytext=(row["i"],row["scaled_P"] + 0.2 + anno_fixed_arm_length)
+
+            ################################################################################################################################
+            # if not changing the directions of some annotation arror arms 
             if anno_count not in anno_d.keys():
-                #arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                #                         connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
                 if _invert==False:
                     arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                            connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
+                                            connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_pixel)+",rad=0")
                 else:
                     arrowargs = dict(arrowstyle="-|>",relpos=(0,1),color="#ebebeb",
-                                            connectionstyle="arc,angleA=0,armA=0,angleB=-90,armB="+str(armB_length_in_point)+",rad=0")
+                                            connectionstyle="arc,angleA=0,armA=0,angleB=-90,armB="+str(armB_length_in_pixel)+",rad=0")
             else:
-                # adjuest horizontal direction
+                # if not changing the directions of some annotation arror arms 
+                # adjust horizontal direction
                 xy=(row["i"],row["scaled_P"])
                 if anno_d[anno_count] in ["right","left","l","r"]:
                     if anno_d[anno_count]=="right" or anno_d[anno_count]=="r": 
@@ -170,7 +191,7 @@ def annotate_single(
                     elif anno_d[anno_count]=="left" or anno_d[anno_count]=="l":
                         arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
                                                 connectionstyle="arc,angleA=-135,armA="+str( anno_d[anno_count][1])+",angleB=135,armB="+str( anno_d[anno_count][1])+",rad=0")
-            
+            ################################################################################################################################
             
             if "r" in mode:
                 arrowargs["color"] = "black" 
@@ -179,16 +200,19 @@ def annotate_single(
                     bbox_para[key]=value
             else:
                 bbox_para=None
-            
+
+            ################################################################################################################################
             if  _invert==False:
-                anno_default = {"rotation":40,"fontstyle":"italic","ha":"left","va":"bottom","fontsize":anno_fontsize,"fontweight":"normal","fontfamily":font_family}
+                anno_default = {"rotation":40, "fontstyle":"italic","ha":"left","va":"bottom","fontsize":anno_fontsize,"fontweight":"normal","fontfamily":font_family}
             else:
-                anno_default = {"rotation":-40,"fontstyle":"italic","ha":"left","va":"top","fontsize":anno_fontsize,"fontweight":"normal","fontfamily":font_family}
+                anno_default = {"rotation":-40,"fontstyle":"italic","ha":"left","va":"top",   "fontsize":anno_fontsize,"fontweight":"normal","fontfamily":font_family}
 
+            ################################################################################################################################
             if anno_style == "expand" :
                 anno_default["rotation"] = 90
             if anno_style == "tight" :
                 anno_default["rotation"] = 90
+            ################################################################################################################################
 
             for key,value in anno_args.items():
                 anno_default[key]=value
@@ -196,12 +220,15 @@ def annotate_single(
                 if row["i"] in highlight_i:
                     for key,value in highlight_anno_args.items():
                         anno_default[key]=value
-            
+            ################################################################################################################################
             if anno_adjust==True:
                 if  _invert==False:
                     arrowargs=dict(arrowstyle='-|>', color='grey', shrinkA=10, linewidth=0.1, relpos=(0,0.5))
                 else:
                     arrowargs=dict(arrowstyle='-|>', color='grey', shrinkA=10, linewidth=0.1, relpos=(1,0.5))
+            ################################################################################################################################
+            for key,value in arrow_kwargs.items():
+                arrowargs[key]=value
 
             anno_to_adjust = ax1.annotate(annotation_text,
                         xy=xy,
@@ -213,6 +240,8 @@ def annotate_single(
                         )
             anno_to_adjust_list.append(anno_to_adjust) 
             anno_count +=1
+            ################################################################################################################################
+        
         #anno_adjust_keyargs = {"arrowprops":dict(arrowstyle='->', color='grey', linewidth=0.1,relpos=(0.5,0.5))}
         if anno_adjust==True:
             log.write(" -Auto-adjusting text positions...", verbose=verbose)
@@ -270,6 +299,7 @@ def annotate_pair(
     pos="POS",
     repel_force=0.02,
     verbose=True,
+    arrow_kwargs=None,
     log=Log()
 ):
     if anno is not None:
@@ -354,15 +384,25 @@ def annotate_pair(
                             arm_scale = arm_scale_d[anno_count]
 
                     # vertical arm length in pixels
-                    armB_length_in_point = ax.transData.transform((skip,1.15*maxy_anno))[1]-ax.transData.transform((skip, row["scaled_P"]+1))[1]-arm_offset/2
-                    # times arm_scale to increase or reduce the length
-                    armB_length_in_point = armB_length_in_point*arm_scale
+                    # Annotation y : 1.15 * maxy_anno
+                    # Top dot:  1 * maxy_anno
+                    # armB_length_in_point_raw = 0.15 * maxy_anno -> gap_pixel
+                    # Fixed Offset: 0.5 * 0.15 * gap_pixel
+
+                    #Calculate armB length in pixels
+                    # arm_scale: raise up the ceiling
+                    gap_pixel =                (ax1.transData.transform((0,1.15*maxy_anno*arm_scale))[1]-ax1.transData.transform((0, maxy_anno*arm_scale))[1])*0.5
+
+                    armB_length_in_pixel_raw =  ax1.transData.transform((0,1.15*maxy_anno*arm_scale))[1]-ax1.transData.transform((0, row["scaled_P"]+1))[1] 
+                    
+                    armB_length_in_pixel = armB_length_in_pixel_raw - gap_pixel
                     
                     if arm_scale>=1:
-                        armB_length_in_point= armB_length_in_point if armB_length_in_point>0 else 0 #ax.transData.transform((skip, maxy_anno+2))[1]-ax.transData.transform((skip,  row["scaled_P"]+1))[1] 
+                        armB_length_in_pixel= armB_length_in_pixel if armB_length_in_pixel>0 else 0
+                    
                     if anno_fixed_arm_length is not None:
                         anno_fixed_arm_length_factor = ax.transData.transform((skip,anno_fixed_arm_length))[1]-ax.transData.transform((skip,0))[1] 
-                        armB_length_in_point = anno_fixed_arm_length_factor
+                        armB_length_in_pixel = anno_fixed_arm_length_factor
                     
                     if anno==True:
                         if row[snpid] in anno_alias.keys():
@@ -383,24 +423,24 @@ def annotate_pair(
                     xytext=(last_pos,1.15*maxy_anno*arm_scale)
                     
                     if anno_fixed_arm_length is not None:
-                        armB_length_in_point = anno_fixed_arm_length
+                        armB_length_in_pixel = anno_fixed_arm_length
                         xytext=(row["i"],row["scaled_P"]+0.2+anno_fixed_arm_length)
                     
                     if anno_count not in anno_d.keys():
                         if index==0:
                             #upper panel
-                            if armB_length_in_point <5:
+                            if armB_length_in_pixel <5:
                                 arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",connectionstyle="arc,armA=0,armB=0,rad=0.")
                             else:  
                                 arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
+                                                connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_pixel)+",rad=0")
                         else:
                             #lower panel
-                            if armB_length_in_point <5:
+                            if armB_length_in_pixel <5:
                                 arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",connectionstyle="arc,armA=0,armB=0,rad=0.")
                             else:
                                 arrowargs = dict(arrowstyle="-|>",relpos=(0,1),color="#ebebeb",
-                                                    connectionstyle="arc,angleA=0,armA=0,angleB=-90,armB="+str(armB_length_in_point)+",rad=0")
+                                                    connectionstyle="arc,angleA=0,armA=0,angleB=-90,armB="+str(armB_length_in_pixel)+",rad=0")
                     
                     else:
                         xy=(row["i"],row["scaled_P"])
@@ -441,6 +481,7 @@ def annotate_pair(
                             arrowargs=dict(arrowstyle='-|>', color='grey', shrinkA=10, linewidth=0.1, relpos=(0,0.5))
                         else:
                             arrowargs=dict(arrowstyle='-|>', color='grey', shrinkA=10, linewidth=0.1, relpos=(1,0.5))
+
                     
                     anno_to_adjust = ax.annotate(annotation_text,
                             xy=xy,
@@ -478,204 +519,4 @@ def annotate_pair(
                             )
     else:
         log.write(" -Skip annotating", verbose=verbose)
-    return ax1,ax5
-
-
-# subtype plot
-def annotate_subtype(
-    sumstats,
-    anno,
-    mode,
-    ax1,
-    highlight_i,
-    to_annotate,
-    anno_d,
-    anno_alias,
-    anno_style,
-    anno_args,
-    arm_scale,
-    anno_max_iter,
-    arm_scale_d,
-    arm_offset,
-    anno_adjust,
-    anno_fixed_arm_length,
-    maxy,
-    anno_fontsize,
-    region,
-    region_anno_bbox_args,
-    skip,
-    snpid="SNPID",
-    chrom="CHR",
-    pos="POS",
-    repel_force=0.02,
-    verbose=True,
-    log=Log()
-):
-    if anno and (to_annotate.empty is not True):
-        #initiate a list for text and a starting position
-        text = []
-        last_pos=0
-        anno_count=0
-        to_annotate = to_annotate.sort_values(by=[chrom,pos])
-        ## log : annotation column
-        if anno==True:
-                annotation_col="CHR:POS"
-        elif anno:
-                annotation_col=anno
-        log.write(" -Annotating using column "+annotation_col+"...", verbose=verbose)
-        
-        ## calculate y span
-        if region is not None:
-            y_span = region[2] - region[1]
-        else:
-            y_span = sumstats["i"].max()-sumstats["i"].min()
-        
-        log.write(" -Adjusting text positions with repel_force={}...".format(repel_force), verbose=verbose)
-        if anno_style == "expand" :
-            to_annotate.loc[:, "ADJUSTED_i"] = adjust_text_position(to_annotate["i"].values.copy(), y_span, repel_force,max_iter=anno_max_iter,log=log,verbose=verbose)
-        ##  iterate through variants to be annotated
-        anno_to_adjust_list = list()
-        
-        for rowi,row in to_annotate.iterrows():
-            
-            # avoid text overlapping
-            ## adjust x to avoid overlapping################################################################
-            if anno_style == "right" :
-                #right style
-                if row["i"]>last_pos+repel_force*y_span:
-                    last_pos=row["i"]
-                else:
-                    last_pos+=repel_force*y_span
-            elif anno_style == "expand" :
-                #expand style
-                last_pos = row["ADJUSTED_i"]
-                anno_args["rotation"] = 90
-            elif anno_style == "tight" :
-                #tight style
-                anno_fixed_arm_length = 1
-                anno_adjust = True
-                anno_args["rotation"] = 90
-            else:
-                pass
-            ################################################################
-            #shrink or increase the arm
-            if arm_scale_d is not None:
-                if anno_count not in arm_scale_d.keys():
-                    arm_scale =1
-                else:
-                    arm_scale = arm_scale_d[anno_count]
-            ################################################################
-
-            # vertical arm length in pixels
-            armB_length_in_point = ax1.transData.transform((skip,1.15*maxy))[1]-ax1.transData.transform((skip, row["scaled_P"]+1))[1]-arm_offset/2
-            # scale if needed
-            armB_length_in_point = armB_length_in_point*arm_scale
-            ################################################################
-            if arm_scale>=1:
-                armB_length_in_point= armB_length_in_point if armB_length_in_point>0 else ax1.transData.transform((skip, maxy+2))[1]-ax1.transData.transform((skip,  row["scaled_P"]+1))[1] 
-            ###if anno_fixed_arm_length #############################################################
-            if anno_fixed_arm_length is not None:
-                anno_fixed_arm_length_factor = ax1.transData.transform((skip,anno_fixed_arm_length))[1]-ax1.transData.transform((skip,0))[1] 
-                armB_length_in_point = anno_fixed_arm_length_factor
-            ################################################################################################################################
-            # annotation alias
-            if anno==True:
-                if row[snpid] in anno_alias.keys():
-                    annotation_text = anno_alias[row[snpid]]
-                else:
-                    annotation_text="Chr"+ str(row[chrom]) +":"+ str(int(row[pos]))
-            elif anno:
-                annotation_text=row["Annotation"]
-            
-            #
-            fontweight = "normal"
-            if len(highlight_i) >0:
-                if row["i"] in highlight_i:
-                    fontweight = "bold"
-
-            
-            xy=(row["i"],row["scaled_P"]+0.2)
-            xytext=(last_pos, 1.15*maxy*arm_scale)
-            
-            if anno_fixed_arm_length is not None:
-                armB_length_in_point = anno_fixed_arm_length
-                xytext=(row["i"],row["scaled_P"]+0.2+anno_fixed_arm_length)
-            
-            if anno_count not in anno_d.keys():
-                #arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                #                         connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
-                arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                            connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
-            else:
-                # adjuest direction
-                xy=(row["i"],row["scaled_P"])
-                if anno_d[anno_count] in ["right","left","l","r"]:
-                    if anno_d[anno_count]=="right" or anno_d[anno_count]=="r": 
-                        armoffsetall = (ax1.transData.transform(xytext)[0]-ax1.transData.transform(xy)[0])*np.sqrt(2)
-                        armoffsetb = arm_offset 
-                        armoffseta = armoffsetall - armoffsetb   
-                        arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=-135,armA="+str(armoffseta)+",angleB=45,armB="+str(armoffsetb)+",rad=0")
-                    elif anno_d[anno_count]=="left" or anno_d[anno_count]=="l":
-                        arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=-135,armA="+str(arm_offset)+",angleB=135,armB="+str(arm_offset)+",rad=0")
-                else:
-                    if anno_d[anno_count][0]=="right" or anno_d[anno_count][0]=="r": 
-                        armoffsetall = (ax1.transData.transform(xytext)[0]-ax1.transData.transform(xy)[0])*np.sqrt(2)
-                        armoffsetb = anno_d[anno_count][1] 
-                        armoffseta = armoffsetall - armoffsetb   
-                        arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=-135,armA="+str(armoffseta)+",angleB=45,armB="+str(armoffsetb)+",rad=0")
-                    elif anno_d[anno_count]=="left" or anno_d[anno_count]=="l":
-                        arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=-135,armA="+str( anno_d[anno_count][1])+",angleB=135,armB="+str( anno_d[anno_count][1])+",rad=0")
-            
-            
-            if "r" in mode:
-                arrowargs["color"] = "black" 
-                bbox_para=dict(boxstyle="round", fc="white",zorder=3)
-                for key,value in region_anno_bbox_args.items():
-                    bbox_para[key]=value
-            else:
-                bbox_para=None
-            
-            anno_default = {"rotation":40,"style":"italic","ha":"left","va":"bottom","fontsize":anno_fontsize,"fontweight":fontweight}
-            for key,value in anno_args.items():
-                anno_default[key]=value
-
-            if anno_adjust==True:
-                arrowargs=dict(arrowstyle='-|>', color='grey', shrinkA=10, linewidth=0.1, relpos=(0,0.5))
-            anno_to_adjust = ax1.annotate(annotation_text,
-                        xy=xy,
-                        xytext=xytext,
-                        bbox=bbox_para,
-                        arrowprops=arrowargs,
-                        zorder=100,
-                        **anno_default
-                        )
-            anno_to_adjust_list.append(anno_to_adjust) 
-            anno_count +=1
-        #anno_adjust_keyargs = {"arrowprops":dict(arrowstyle='->', color='grey', linewidth=0.1,relpos=(0.5,0.5))}
-        if anno_adjust==True:
-            log.write(" -Auto-adjusting text positions...", verbose=verbose)
-            adjust_text(texts = anno_to_adjust_list,
-                        autoalign=False, 
-                        only_move={'points':'x', 'text':'x', 'objects':'x'},
-                        ax=ax1,
-                        precision=0.02,
-                        force_text=(repel_force,repel_force),
-                        expand_text=(1,1),
-                        expand_objects=(0,0),
-                        expand_points=(0,0),
-                        va="bottom",
-                        ha='left',
-                        avoid_points=False,
-                        lim =100
-                        #kwargs = anno_adjust_keyargs
-                        )
-        
-    else:
-        log.write(" -Skip annotating", verbose=verbose)
-    
-    return ax1
-
+    return ax1,ax5

gwaslab/viz_aux_property.py

@@ -0,0 +1,2 @@
+import matplotlib.pyplot as plt
+

gwaslab/viz_aux_quickfix.py

@@ -80,6 +80,7 @@ def _quick_fix_chr(seires, chr_dict,log=Log(), verbose=True):
     '''
     if pd.api.types.is_string_dtype(seires) == True:
         # if chr is string dtype: convert using chr_dict
+        seires = seires.astype("string")
         seires = seires.map(chr_dict, na_action="ignore")
     seires = np.floor(pd.to_numeric(seires, errors='coerce')).astype('Int64')
     return seires
@@ -93,6 +94,12 @@ def _quick_fix_pos(seires,log=Log(), verbose=True):
     return seires
 
 
+def _dropna_in_cols(sumstats, cols, log=Log(), verbose=True):
+    to_drop = sumstats[cols].isna().any(axis=1)
+    log.write(" -Dropping {} variants due to missing values in {}.".format(sum(to_drop),cols))
+    return sumstats.loc[~to_drop,:]
+
+
 def _get_largenumber(*args,log=Log(), verbose=True):
     '''
     get a helper large number, >> max(pos)
@@ -330,7 +337,7 @@ def _cut(series, mode,cutfactor,cut,skip, ylabels, cut_log, verbose, lines_to_pl
                 if "b" not in mode:
                     log.write(" -Minus log10(P) values above " + str(cut)+" will be shrunk with a shrinkage factor of " + str(cutfactor)+"...", verbose=verbose)
                 else:
-                    log.write(" -Minus DENSITY values above " + str(cut)+" will be shrunk with a shrinkage factor of " + str(cutfactor)+"...", verbose=verbose)
+                    log.write(" -DENSITY values above " + str(cut)+" will be shrunk with a shrinkage factor of " + str(cutfactor)+"...", verbose=verbose)
 
                 maxticker=int(np.round(series.max(skipna=True)))
 
@@ -448,4 +455,4 @@ def _jagged_y(cut,skip,ax1,mode,mqqratio,jagged_len,jagged_wid, log=Log(), verbo
     ax1.plot((x0,-dx), (tycut,tycut+dy), zorder=1001, **kwargs)
     ax1.plot((-dx,+dx), (tycut+dy,tycut+3*dy), zorder=1001, **kwargs)
     ax1.plot((+dx,x0), (tycut+3*dy,tycut+4*dy), zorder=1001,  **kwargs)
-    return ax1
+    return ax1

gwaslab/viz_aux_save_figure.py

@@ -50,7 +50,8 @@ def get_default_path(keyword,fmt="png"):
                         "ldscrg":"ldscrg_heatmap",
                         "miami":"miami",
                         "esc":"effect_size_comparision",
-                        "afc":"allele_frequency_comparision"
+                        "afc":"allele_frequency_comparision",
+                        "gwheatmap":"genome_wide_heatmap"
                         }
     prefix = path_dictionary[keyword]
     count = 1