gwaslab 3.4.38__py3-none-any.whl → 3.4.39__py3-none-any.whl

gwaslab/viz_plot_regionalplot.py

@@ -86,7 +86,7 @@ def _plot_regional(
                                         region_ld_threshold = region_ld_threshold, 
                                         region_ld_colors = region_ld_colors, 
                                         marker_size= marker_size,
-                                        log=log)
+                                        log=log,verbose=verbose)
         else:
             ax1, lead_id = _pinpoint_lead(sumstats = sumstats,
                                             ax1 = ax1, 
@@ -94,14 +94,14 @@ def _plot_regional(
                                             region_ld_threshold = region_ld_threshold, 
                                             region_ld_colors = region_ld_colors1, 
                                             marker_size= marker_size,
-                                            log=log)
+                                            log=log,verbose=verbose)
             ax1, lead_id2 = _pinpoint_lead(sumstats = sumstats,
                                             ax1 = ax1, 
                                             region_ref=region_ref_second,
                                             region_ld_threshold = region_ld_threshold, 
                                             region_ld_colors = region_ld_colors2, 
                                             marker_size= marker_size,
-                                            log=log)
+                                            log=log,verbose=verbose)
 
         if (vcf_path is not None) and region_ld_legend:
             if region_ref_second is None:
@@ -240,7 +240,7 @@ def _plot_regional(
     return ax1, ax3, ax4, cbar, lead_snp_i, lead_snp_i2
 
 # + ###########################################################################################################################################################################
-def _get_lead_id(sumstats=None, region_ref=None, log=None):
+def _get_lead_id(sumstats=None, region_ref=None, log=None, verbose=True):
     region_ref_to_check = copy.copy(region_ref)
     try: 
         if len(region_ref_to_check)>0 and type(region_ref_to_check) is not str:
@@ -260,23 +260,23 @@ def _get_lead_id(sumstats=None, region_ref=None, log=None):
     if region_ref_to_check is not None:
         if type(lead_id) is list:
             if len(lead_id)==0 :
-                log.write(" -WARNING: {} not found. Roll back to lead variant...".format(region_ref_to_check))
+                log.warning("{} not found. Roll back to lead variant...".format(region_ref_to_check))
                 lead_id = sumstats["scaled_P"].idxmax()
         else:
             log.write(" -Reference variant ID: {} - {}".format(region_ref_to_check, lead_id))
 
     if lead_id is None:
-        log.write(" -Extracting lead variant...")
+        log.write(" -Extracting lead variant...", verbose=verbose)
         lead_id = sumstats["scaled_P"].idxmax()
 
     return lead_id
 
-def _pinpoint_lead(sumstats,ax1,region_ref, region_ld_threshold, region_ld_colors, marker_size, log):
+def _pinpoint_lead(sumstats,ax1,region_ref, region_ld_threshold, region_ld_colors, marker_size, log, verbose):
     if region_ref is None:
-        log.write(" -Extracting lead variant...")
+        log.write(" -Extracting lead variant..." , verbose=verbose)
         lead_id = sumstats["scaled_P"].idxmax()
     else:
-        lead_id = _get_lead_id(sumstats, region_ref, log)
+        lead_id = _get_lead_id(sumstats, region_ref, log, verbose)
         
     ax1.scatter(sumstats.loc[lead_id,"i"],sumstats.loc[lead_id,"scaled_P"],
             color=region_ld_colors[-1],
@@ -398,7 +398,7 @@ def _plot_gene_track(
     log=Log()):
     
     # load gtf
-    if verbose: log.write(" -Loading gtf files from:" + gtf_path)
+    log.write(" -Loading gtf files from:" + gtf_path, verbose=verbose)
     uniq_gene_region,exons = process_gtf(   gtf_path = gtf_path ,
                                             region = region, 
                                             region_flank_factor = region_flank_factor,
@@ -416,7 +416,7 @@ def _plot_gene_track(
     font_size_in_pixels= taf[2] * pixels_per_track
     font_size_in_points =  font_size_in_pixels * pixels_per_point
     linewidth_in_points=   pixels_per_track * pixels_per_point
-    if verbose: log.write(" -plotting gene track..")
+    log.write(" -plotting gene track..", verbose=verbose)
     
     sig_gene_name = "Undefined"
     sig_gene_name2 = "Undefined"
@@ -424,6 +424,7 @@ def _plot_gene_track(
     texts_to_adjust_middle = []
     texts_to_adjust_right = []
     for index,row in uniq_gene_region.iterrows():
+
         gene_color="#020080"
         #if row[6][0]=="+":
         if row["strand"][0]=="+":
@@ -496,7 +497,7 @@ def _plot_gene_track(
         ax3.plot((gene_track_start_i+row["start"],gene_track_start_i+row["end"]),
                     (row["stack"]*2,row["stack"]*2),linewidth=linewidth_in_points*taf[3],color=exon_color,solid_capstyle="butt")
 
-    if verbose: log.write(" -Finished plotting gene track..")
+    log.write(" -Finished plotting gene track..", verbose=verbose)
 
     return ax3,texts_to_adjust_middle
 
@@ -504,25 +505,26 @@ def _plot_gene_track(
 # Helpers    
 # -############################################################################################################################################################################
 def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, verbose, pos ,nea,ea, region_ld_threshold, vcf_chr_dict,tabix):
-    if verbose: log.write("Start to load reference genotype...")
-    if verbose: log.write(" -reference vcf path : "+ vcf_path)
+    log.write("Start to load reference genotype...", verbose=verbose)
+    log.write(" -reference vcf path : "+ vcf_path, verbose=verbose)
 
 
 
     # load genotype data of the targeted region
     ref_genotype = read_vcf(vcf_path,region=vcf_chr_dict[region[0]]+":"+str(region[1])+"-"+str(region[2]),tabix=tabix)
     if ref_genotype is None:
-        if verbose: log.write(" -Warning: no data was retrieved. Skipping ...")
+        log.warning("No data was retrieved. Skipping ...")
         ref_genotype=dict()
         ref_genotype["variants/POS"]=np.array([],dtype="int64")
-    if verbose: log.write(" -Retrieving index...")
-    if verbose: log.write(" -Ref variants in the region: {}".format(len(ref_genotype["variants/POS"])))
+    log.write(" -Retrieving index...", verbose=verbose)
+    log.write(" -Ref variants in the region: {}".format(len(ref_genotype["variants/POS"])), verbose=verbose)
     # match sumstats pos and ref pos: 
     # get ref index for its first appearance of sumstats pos
      #######################################################################################
     def match_varaint(x):
         # x: "POS,NEA,EA"
         if np.any(ref_genotype["variants/POS"] == x.iloc[0]):
+            # position match
             if len(np.where(ref_genotype["variants/POS"] == x.iloc[0] )[0])>1:  
             # multiple position matches
                 for j in np.where(ref_genotype["variants/POS"] == x.iloc[0])[0]:
@@ -532,16 +534,15 @@ def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, v
                             return j
                     elif x.iloc[1] in ref_genotype["variants/ALT"][j]:
                         if x.iloc[2] == ref_genotype["variants/REF"][j]:
-                            return j
-                    else:
-                        return None
+                            return j    
+                return None
             else: 
                 # single match
                 return np.where(ref_genotype["variants/POS"] == x.iloc[0] )[0][0] 
         else:
             # no position match
             return None
-    if verbose: log.write(" -Matching variants using POS, NEA, EA ...")
+    log.write(" -Matching variants using POS, NEA, EA ...", verbose=verbose)
     sumstats["REFINDEX"] = sumstats[[pos,nea,ea]].apply(lambda x: match_varaint(x),axis=1)
     #############################################################################################
     #sumstats["REFINDEX"] = sumstats[pos].apply(lambda x: np.where(ref_genotype["variants/POS"] == x )[0][0] if np.any(ref_genotype["variants/POS"] == x) else None)
@@ -551,7 +552,7 @@ def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, v
     if region_ref is None:
         lead_id = sumstats["scaled_P"].idxmax()
     else:
-        lead_id = _get_lead_id(sumstats, region_ref, log)
+        lead_id = _get_lead_id(sumstats, region_ref, log, verbose)
     lead_pos = sumstats.loc[lead_id,pos]
     
     # if lead pos is available: 
@@ -567,12 +568,12 @@ def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, v
         lead_snp_genotype = GenotypeArray([ref_genotype["calldata/GT"][lead_snp_ref_index]]).to_n_alt()
         try:
             if len(set(lead_snp_genotype[0]))==1:
-                log.write(" -WARNING: The variant is mono-allelic in reference VCF. LD can not be calculated.", verbose=verbose)
+                log.warning("The variant is mono-allelic in reference VCF. LD can not be calculated.")
         except:
             pass
         other_snp_genotype = GenotypeArray(ref_genotype["calldata/GT"][other_snps_ref_index]).to_n_alt()
         
-        if verbose: log.write(" -Calculating Rsq...")
+        log.write(" -Calculating Rsq...", verbose=verbose)
         
         if len(other_snp_genotype)>1:
             valid_r2= np.power(rogers_huff_r_between(lead_snp_genotype,other_snp_genotype)[0],2)
@@ -580,7 +581,7 @@ def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, v
             valid_r2= np.power(rogers_huff_r_between(lead_snp_genotype,other_snp_genotype),2)
         sumstats.loc[~sumstats["REFINDEX"].isna(),"RSQ"] = valid_r2
     else:
-        if verbose: log.write(" -Lead SNP not found in reference...")
+        log.write(" -Lead SNP not found in reference...", verbose=verbose)
         sumstats["RSQ"]=None
     
     sumstats["RSQ"] = sumstats["RSQ"].astype("float")
@@ -600,7 +601,7 @@ def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, v
     #####################################################################################################
     if region_ref_second is not None:
 
-        lead_id2 = _get_lead_id(sumstats, region_ref_second, log)
+        lead_id2 = _get_lead_id(sumstats, region_ref_second, log, verbose)
 
         lead_pos2 = sumstats.loc[lead_id2,pos]
         if lead_pos2 in ref_genotype["variants/POS"]:
@@ -615,12 +616,12 @@ def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, v
             lead_snp_genotype = GenotypeArray([ref_genotype["calldata/GT"][lead_snp_ref_index]]).to_n_alt()
             try:
                 if len(set(lead_snp_genotype[0]))==1:
-                    log.write(" -WARNING: The variant is mono-allelic in reference VCF. LD can not be calculated.", verbose=verbose)
+                    log.warning("The variant is mono-allelic in reference VCF. LD can not be calculated.")
             except:
                 pass
             other_snp_genotype = GenotypeArray(ref_genotype["calldata/GT"][other_snps_ref_index]).to_n_alt()
             
-            if verbose: log.write(" -Calculating Rsq...")
+            log.write(" -Calculating Rsq...", verbose=verbose)
             
             if len(other_snp_genotype)>1:
                 valid_r2= np.power(rogers_huff_r_between(lead_snp_genotype,other_snp_genotype)[0],2)
@@ -628,7 +629,7 @@ def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, v
                 valid_r2= np.power(rogers_huff_r_between(lead_snp_genotype,other_snp_genotype),2)
             sumstats.loc[~sumstats["REFINDEX"].isna(),"RSQ2"] = valid_r2
         else:
-            if verbose: log.write(" -Lead SNP not found in reference...")
+            log.write(" -Lead SNP not found in reference...", verbose=verbose)
             sumstats["RSQ2"]=None
 
         sumstats["RSQ2"] = sumstats["RSQ2"].astype("float")
@@ -652,7 +653,7 @@ def process_vcf(sumstats, vcf_path, region,region_ref, region_ref_second, log, v
         #sumstats.loc[lead_id,"LEAD2"]
     ####################################################################################################
 
-    if verbose: log.write("Finished loading reference genotype successfully!")
+    log.write("Finished loading reference genotype successfully!", verbose=verbose)
     return sumstats
 
 # -############################################################################################################################################################################
@@ -714,8 +715,8 @@ def process_gtf(gtf_path,
     # extract protein coding gene
     if region_protein_coding is True:
         #genes_1mb  =  genes_1mb.loc[genes_1mb["gene_biotype"]=="protein_coding",:].copy()
-        pc_genes_1mb_list = genes_1mb.loc[(genes_1mb["feature"]=="gene")& (genes_1mb["gene_biotype"]=="protein_coding"),"name"].values
-        genes_1mb = genes_1mb.loc[genes_1mb["name"].isin(pc_genes_1mb_list),:]
+        pc_genes_1mb_list = genes_1mb.loc[(genes_1mb["feature"]=="gene")& (genes_1mb["gene_biotype"]=="protein_coding") & (genes_1mb["name"]!=""),"name"].values
+        genes_1mb = genes_1mb.loc[(genes_1mb["feature"].isin(["exon","gene"])) & (genes_1mb["name"].isin(pc_genes_1mb_list)),:]
     # extract exon
     exons = genes_1mb.loc[genes_1mb["feature"]=="exon",:].copy()
     

gwaslab/viz_plot_rg_heatmap.py

@@ -8,6 +8,7 @@ import matplotlib
 from gwaslab.g_Log import Log
 import scipy.stats as ss
 from gwaslab.viz_aux_save_figure import save_figure
+
 #################################################################################################
 def convert_p_to_width(p,sig_level):
     width_factor= -np.log10(sig_level)
@@ -54,7 +55,7 @@ def plot_rg(ldscrg,
         save=None,
         save_args=None):
     
-    if verbose: log.write("Start to create ldsc genetic correlation heatmap...")
+    log.write("Start to create ldsc genetic correlation heatmap..." ,verbose=verbose)
     # configure arguments
     if fig_args is None:
         fig_args = {"dpi":300}
@@ -78,14 +79,14 @@ def plot_rg(ldscrg,
         save_args = {}
     
     #drop na records in P column 
-    if verbose: log.write("Raw dataset records:",len(ldscrg))
+    log.write("Raw dataset records:",len(ldscrg) ,verbose=verbose)
     df=ldscrg.dropna(subset=[p]).copy()
     
-    if verbose: log.write(" -Raw dataset non-NA records:",len(df))
+    log.write(" -Raw dataset non-NA records:",len(df) ,verbose=verbose)
     # create unique pair column
     df["p1p2"]=df.apply(lambda x:"_".join(sorted([x[p1],x[p2]])),axis=1)
     
-    if verbose: log.write("Filling diagnal line and duplicated pair for plotting...")
+    log.write("Filling diagnal line and duplicated pair for plotting..." ,verbose=verbose)
     # fill na
     df_fill_reverse = df.loc[(df[p2].isin(df[p1].values)) & (df[p1].isin(df[p2].values)),:].copy()
     df_fill_reverse = df_fill_reverse.rename(columns={p1:p2,p2:p1})
@@ -96,16 +97,23 @@ def plot_rg(ldscrg,
     p2_dup_list = list(df.loc[(df[p1].isin(df[p2].values)),"p1"].values)
     p_dup_list = p2_dup_list + p1_dup_list
     if len(set(p_dup_list)) > 0:
-        if verbose: log.write(" -Diagnal records:", len(set(p_dup_list)))
+        log.write(" -Diagnal records:", len(set(p_dup_list)) ,verbose=verbose)
     df_fill_dia["p1"] = p_dup_list
     df_fill_dia["p2"] = df_fill_dia["p1"] 
     df_fill_dia["rg"] = 1
 
     df_fill_na = pd.DataFrame(columns=df.columns)
     df_fill_na[[p1,p2]] = [(i,j) for i in df[p1].sort_values(ascending=False).drop_duplicates() for j in df[p2].sort_values(ascending=False).drop_duplicates()]
+    
+    to_concate=[]
+    for i in [df,df_fill_reverse,df_fill_dia,df_fill_na]:
+        if len(i)>0:
+            to_concate.append(i.dropna(axis=1))
+    
     # fill diagonal
-    df = pd.concat([df,df_fill_reverse,df_fill_dia,df_fill_na],ignore_index=True).sort_values(by=p).drop_duplicates(subset=[p1,p2])
-    #if verbose: log.write(" -Dataset shape match:", len(df)==)
+    df = pd.concat(to_concate,ignore_index=True).sort_values(by=p).drop_duplicates(subset=[p1,p2])
+    
+    #log.write(" -Dataset shape match:", len(df)==)
     #
     ## remove record with p1 = p2, dropna in P column
     dfp=ldscrg.loc[ldscrg[p1]!=ldscrg[p2],:].dropna(subset=[p]).copy()
@@ -116,11 +124,11 @@ def plot_rg(ldscrg,
     ## drop duplicate and keep only unique pairs 
     dfp = dfp.drop_duplicates(subset=["p1p2"]).copy()
     
-    if verbose: log.write("Valid unique trait pairs:",len(dfp))
-    if verbose: log.write(" -Valid unique trait1:",dfp["p1"].nunique())
-    if verbose: log.write(" -Valid unique trait2:",dfp["p2"].nunique())
-    if verbose: log.write(" -Significant correlations with P < 0.05:",sum(dfp[p]<0.05))
-    if verbose: log.write(" -Significant correlations after Bonferroni correction:",sum(dfp[p]<(0.05/len(dfp))))
+    log.write("Valid unique trait pairs:",len(dfp) ,verbose=verbose)
+    log.write(" -Valid unique trait1:",dfp["p1"].nunique() ,verbose=verbose)
+    log.write(" -Valid unique trait2:",dfp["p2"].nunique() ,verbose=verbose)
+    log.write(" -Significant correlations with P < 0.05:",sum(dfp[p]<0.05) ,verbose=verbose)
+    log.write(" -Significant correlations after Bonferroni correction:",sum(dfp[p]<(0.05/len(dfp))) ,verbose=verbose)
     
     #if correction=="fdr":
         # fdr corrected p
@@ -131,7 +139,7 @@ def plot_rg(ldscrg,
     dfp["fdr_p"]=ss.false_discovery_control(dfp[p],method=fdr_method)
     dfp["fdr"]  =ss.false_discovery_control(dfp[p],method=fdr_method) < 0.05
 
-    if verbose: log.write(" -Significant correlations with FDR <0.05:",sum(dfp["fdr"]))
+    log.write(" -Significant correlations with FDR <0.05:",sum(dfp["fdr"]) ,verbose=verbose)
         # convert to dict for annotation and plotting
     df_rawp = dfp.set_index("p1p2").loc[:,p].to_dict()
     dfp = dfp.set_index("p1p2").loc[:,"fdr_p"].to_dict()
@@ -167,7 +175,7 @@ def plot_rg(ldscrg,
     df["x"]=df[p2].map(dic_p2)
     df["x_y"]=df[p2].map(dic_p1)
     
-    if verbose: log.write("Plotting heatmap...")
+    log.write("Plotting heatmap..." ,verbose=verbose)
     ########ticks###############################################
     fig,ax = plt.subplots(**fig_args)
     
@@ -196,7 +204,7 @@ def plot_rg(ldscrg,
     panno_list={1:{},2:{}}
     rgtoanno=[]
     
-    if verbose: log.write("Full cell : {}-corrected P == {}".format(full_cell[0],full_cell[1]))
+    log.write("Full cell : {}-corrected P == {}".format(full_cell[0],full_cell[1]) ,verbose=verbose)
 
     for i,row in df.iterrows():
         xcenter=row["x"]
@@ -298,11 +306,11 @@ def plot_rg(ldscrg,
 
     # annotate p
     if panno is True:
-        if verbose: log.write("P value annotation text : ")
+        log.write("P value annotation text (Order: Bon -> FDR -> Pnom): " ,verbose=verbose)
         for i,correction in enumerate(corrections):
             for j,sig_level in enumerate(sig_levels):
                 index = len(sig_levels)*i + j
-                if verbose: log.write(" -{} : {}-corrected P < {}".format(panno_texts[index], correction, sig_level))
+                log.write(" -{} : {}-corrected P < {} ".format(panno_texts[index], correction, sig_level) ,verbose=verbose)
         for panno_set_number in panno_list.keys():
             for key, i in panno_list[panno_set_number].items():
                 if panno_set_number == 1:
@@ -318,14 +326,8 @@ def plot_rg(ldscrg,
         ax.set_aspect('equal', adjustable='box')
     
     save_figure(fig, save, keyword="ldscrg",save_args=save_args, log=log, verbose=verbose)
-    #if save:
-    #    if verbose: log.write("Saving plot:")
-    #    if save==True:
-    #        fig.savefig("./ldscrg_heatmap.png",bbox_inches="tight",**save_args)
-    #        log.write(" -Saved to "+ "./ldscrg_heatmap.png" + " successfully!" )
-    #    else:
-    #        fig.savefig(save,bbox_inches="tight",**save_args)
-    #        log.write(" -Saved to "+ save + " successfully!" )
-    if verbose: log.write("Finished creating ldsc genetic correlation heatmap!")
+
+    log.write("Finished creating ldsc genetic correlation heatmap!" ,verbose=verbose)
+
     return fig,ax,log,df
     

gwaslab/viz_plot_stackedregional.py

@@ -59,23 +59,25 @@ def plot_stacked_mqq(objects,
                         log=Log(),
                         **mqq_args
                         ):
+    
     log.write("Start to create stacked mqq plot by iteratively calling plot_mqq:",verbose=verbose)
     # load sumstats
+    
+    ##########################################################################################################################################
     sumstats_list = [] 
     for each_object in objects:
         sumstats_list.append(each_object.data)
 
-
     if fig_args is None:
         fig_args = {"dpi":200}
     if region_lead_grid_line is None:
         region_lead_grid_line = {"alpha":0.5,"linewidth" : 2,"linestyle":"--","color":"#FF0000"}
     if title_pos is None:
-        title_pos = [0.03,0.97]
+        title_pos = [0.01,0.97]
     if title_args is None:
         title_args = {}
-    # create figure and axes
-
+    
+    # create figure and axes ##################################################################################################################
     if mode=="r":
         if len(vcfs)==1:
             vcfs = vcfs *len(sumstats_list)
@@ -105,27 +107,29 @@ def plot_stacked_mqq(objects,
                                           **fig_args)
         plt.subplots_adjust(hspace=region_hspace)
 
-#
-
-
+    ##########################################################################################################################################
     mqq_args_for_each_plot = _sort_args(mqq_args, n_plot)
-    
-
-
+    ##########################################################################################################################################
+    # get x axis dict
     if mode=="m":
         _posdiccul = _get_chrom_dic(sumstats_list,chrom="CHR",pos="POS",chrpad=0.02)
     else:
         _posdiccul=None
     
+    ##########################################################################################################################################
+    # a dict to store lead variants of each plot
     lead_variants_is={}
+
+    ##########################################################################################################################################
     # plot manhattan plot
     for index,sumstats in enumerate(sumstats_list):
+
+        #################################################################
         if mode=="m" or mode=="r":
             figax = (fig,axes[index],axes[-1])
         elif mode=="mqq":
             figax = (fig,axes[index,0],axes[index,1])
-        
-        
+        #################################################################
         if index==0:
             # plot last m and gene track 
             fig,log,lead_i,lead_i2 = mqqplot(sumstats,
@@ -151,6 +155,7 @@ def plot_stacked_mqq(objects,
                             )  
             lead_variants_is[index] = (lead_i,lead_i2)
         else:
+            # plot only the scatter plot
             fig,log,lead_i,lead_i2 = mqqplot(sumstats,
                             chrom="CHR",
                             pos="POS",
@@ -178,13 +183,32 @@ def plot_stacked_mqq(objects,
     # adjust labels
     # drop labels for each plot 
     # set a common laebl for all plots
-    for index in range(n_plot):
-        axes[index].set_ylabel("")
+
     
     if titles is not None:
         for index,title in enumerate(titles):
             axes[index].text(title_pos[0], title_pos[1] , title, transform=axes[index].transAxes,ha="left", va='top',**title_args)
+    ##########################################################################################################################################
+    # draw the line for lead variants
+    _draw_grid_line_for_lead_variants(mode, lead_variants_is, n_plot, axes, region_lead_grid_line)
+    
+    ##########################################################################################################################################  
+    _drop_old_y_labels(axes, n_plot)
+    
+    _add_new_y_label(mode, fig, gene_track_height,n_plot,subplot_height )
+    
+    ##########################################################################################################################################
+    save_figure(fig = fig, save = save, keyword= "stacked_" + mode, save_args=save_args, log = log, verbose=verbose)
+    
+    log.write("Finished creating stacked mqq plot by iteratively calling plot_mqq.",verbose=verbose)
+    
+    return fig, log
 
+def _drop_old_y_labels(axes, n_plot):
+    for index in range(n_plot):
+        axes[index].set_ylabel("")
+
+def _draw_grid_line_for_lead_variants(mode, lead_variants_is, n_plot, axes, region_lead_grid_line):
     if mode=="r":
         for index, sig_is in lead_variants_is.items():
             for sig_i in sig_is:
@@ -192,19 +216,14 @@ def plot_stacked_mqq(objects,
                     for each_axis_index in range(n_plot + 1):    
                         axes[each_axis_index].axvline(x=sig_i, zorder=2,**region_lead_grid_line)
 
-
+def _add_new_y_label(mode, fig, gene_track_height,n_plot,subplot_height ):
     gene_track_height_ratio = gene_track_height/(gene_track_height + n_plot*subplot_height)
     ylabel_height = (1 - gene_track_height_ratio)*0.5 + gene_track_height_ratio
     if mode=="r":
         fig.text(0.08, ylabel_height , "$-log_{10}(P)$", va='center', rotation='vertical')
         fig.text(0.93, ylabel_height, "Recombination rate(cM/Mb)", va='center', rotation=-90)
     elif mode=="m":
-        fig.text(0.08, ylabel_height , "$-log_{10}(P)$", va='center', rotation='vertical')
-
-    save_figure(fig = fig, save = save, keyword= "stacked_" + mode, save_args=save_args, log = log, verbose=verbose)
-    log.write("Finished creating stacked mqq plot by iteratively calling plot_mqq.",verbose=verbose)
-    return fig, log
-
+        fig.text(0.08, ylabel_height , "$-log_{10}(P)$", va='center', rotation='vertical')    
 
 def _sort_args(mqq_args, n_plot):
     mqq_args_for_each_plot={i:{} for i in range(n_plot)}