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

gwaslab/viz_plot_compare_effect.py

@@ -99,14 +99,14 @@ def compare_effect(path1,
     if anno_het ==True:
         is_q=True
 
-    if verbose: log.write("Start to process the raw sumstats for plotting...")
+    log.write("Start to process the raw sumstats for plotting...")
     
     ######### 1 check the value used to plot
     if mode not in ["Beta","beta","BETA","OR","or"]:
         raise ValueError("Please input Beta or OR")
     
     if type(path1) is Sumstats:
-        if verbose: log.write("Path1 is gwaslab Sumstats object...")
+        log.write("Path1 is gwaslab Sumstats object...")
         if cols_name_list_1 is None:
             cols_name_list_1 = ["SNPID","P","EA","NEA","CHR","POS"]
         if effect_cols_list_1 is None:
@@ -115,10 +115,10 @@ def compare_effect(path1,
             else:
                 effect_cols_list_1 = ["OR","OR_95L","OR_95U"]
     elif type(path1) is pd.DataFrame:
-        if verbose: log.write("Path1 is pandas DataFrame object...")
+        log.write("Path1 is pandas DataFrame object...")
 
     if type(path2) is Sumstats:
-        if verbose: log.write("Path2 is gwaslab Sumstats object...")
+        log.write("Path2 is gwaslab Sumstats object...")
         if cols_name_list_2 is None:
             cols_name_list_2 = ["SNPID","P","EA","NEA","CHR","POS"]
         if effect_cols_list_2 is None:
@@ -127,10 +127,10 @@ def compare_effect(path1,
             else:
                 effect_cols_list_2 = ["OR","OR_95L","OR_95U"]
     elif type(path2) is pd.DataFrame:
-        if verbose: log.write("Path2 is pandas DataFrame object...")
+        log.write("Path2 is pandas DataFrame object...")
     
     ######### 2 extract snplist2
-    if verbose: log.write(" -Loading "+label[1]+" SNP list in memory...")    
+    log.write(" -Loading "+label[1]+" SNP list in memory...")    
     
     if type(path2) is Sumstats:
         sumstats = path2.data[[cols_name_list_2[0]]].copy()
@@ -148,7 +148,7 @@ def compare_effect(path1,
         cols_to_extract = [cols_name_list_1[0],cols_name_list_1[1],cols_name_list_1[4],cols_name_list_1[5]]
  
     ######### 4 load sumstats1
-    if verbose: log.write(" -Loading sumstats for "+label[0]+":",",".join(cols_to_extract))
+    log.write(" -Loading sumstats for "+label[0]+":",",".join(cols_to_extract))
     
     if type(path1) is Sumstats:
         sumstats = path1.data[cols_to_extract].copy()
@@ -163,7 +163,7 @@ def compare_effect(path1,
         sumstats[cols_name_list_1[1]] = np.power(10,-sumstats[cols_name_list_1[1]])
     ######### 5 extract the common set
     common_snp_set = common_snp_set.intersection(sumstats[cols_name_list_1[0]].values)
-    if verbose: log.write(" -Counting  variants available for both datasets:",len(common_snp_set)," variants...")
+    log.write(" -Counting  variants available for both datasets:",len(common_snp_set)," variants...")
     
     ######### 6 rename the sumstats
     rename_dict = { cols_name_list_1[0]:"SNPID",
@@ -179,16 +179,16 @@ def compare_effect(path1,
     ######### 7 exctract only available variants from sumstats1 
     sumstats = sumstats.loc[sumstats["SNPID"].isin(common_snp_set),:]
     
-    if verbose: log.write(" -Using only variants available for both datasets...")
+    log.write(" -Using only variants available for both datasets...")
     ######### 8 extact SNPs for comparison 
     
     if snplist is not None: 
         ######### 8.1 if a snplist is provided, use the snp list
-        if verbose: log.write(" -Extract variants in the given list from "+label[0]+"...")
+        log.write(" -Extract variants in the given list from "+label[0]+"...")
         sig_list_1 = sumstats.loc[sumstats["SNPID"].isin(snplist),:].copy()
     else:
         ######### 8,2 otherwise use the sutomatically detected lead SNPs
-        if verbose: log.write(" -Extract lead variants from "+label[0]+"...")
+        log.write(" -Extract lead variants from "+label[0]+"...")
         sig_list_1 = getsig(sumstats,"SNPID","CHR","POS","P", verbose=verbose,sig_level=sig_level,**get_lead_args)
     
     if drop==True:
@@ -200,7 +200,7 @@ def compare_effect(path1,
     else:
         cols_to_extract = [cols_name_list_2[0],cols_name_list_2[1],cols_name_list_2[4],cols_name_list_2[5]]
     
-    if verbose: log.write(" -Loading sumstats for "+label[1]+":",",".join(cols_to_extract))
+    log.write(" -Loading sumstats for "+label[1]+":",",".join(cols_to_extract))
     
     if type(path2) is Sumstats:
         sumstats = path2.data[cols_to_extract].copy()
@@ -228,10 +228,10 @@ def compare_effect(path1,
     ######## 12 extact SNPs for comparison 
     if snplist is not None: 
         ######### 12.1 if a snplist is provided, use the snp list
-        if verbose: log.write(" -Extract snps in the given list from "+label[1]+"...")
+        log.write(" -Extract snps in the given list from "+label[1]+"...")
         sig_list_2 = sumstats.loc[sumstats["SNPID"].isin(snplist),:].copy()
     else: 
-        if verbose: log.write(" -Extract lead snps from "+label[1]+"...")
+        log.write(" -Extract lead snps from "+label[1]+"...")
         ######### 12.2 otherwise use the sutomatically detected lead SNPs
         sig_list_2 = getsig(sumstats,"SNPID","CHR","POS","P",
                                  verbose=verbose,sig_level=sig_level,**get_lead_args)
@@ -240,7 +240,7 @@ def compare_effect(path1,
 
     ######### 13 Merge two list using SNPID
     ##############################################################################
-    if verbose: log.write("Merging snps from "+label[0]+" and "+label[1]+"...")
+    log.write("Merging snps from "+label[0]+" and "+label[1]+"...")
     
     sig_list_merged = pd.merge(sig_list_1,sig_list_2,left_on="SNPID",right_on="SNPID",how="outer",suffixes=('_1', '_2'))
     #     SNPID       P_1       P_2
@@ -260,7 +260,7 @@ def compare_effect(path1,
         cols_to_extract = [cols_name_list_1[0],cols_name_list_1[1], cols_name_list_1[2],cols_name_list_1[3], effect_cols_list_1[0], effect_cols_list_1[1], effect_cols_list_1[2]]
     
     if len(eaf)>0: cols_to_extract.append(eaf[0])   
-    if verbose: log.write(" -Extract statistics of selected variants from "+label[0]+" : ",",".join(cols_to_extract) )
+    log.write(" -Extract statistics of selected variants from "+label[0]+" : ",",".join(cols_to_extract) )
     
     if type(path1) is Sumstats:
         sumstats = path1.data[cols_to_extract].copy()
@@ -300,7 +300,7 @@ def compare_effect(path1,
         sumstats = drop_duplicate_and_na(sumstats,  sort_by="P_1", log=log , verbose=verbose)
     sumstats.drop("P_1",axis=1,inplace=True)
 
-    if verbose: log.write(" -Merging "+label[0]+" effect information...")
+    log.write(" -Merging "+label[0]+" effect information...", verbose=verbose)
     
     sig_list_merged = pd.merge(sig_list_merged,sumstats,
                                left_on="SNPID",right_on="SNPID",
@@ -316,7 +316,7 @@ def compare_effect(path1,
     ## check if eaf column is provided.
     if len(eaf)>0: cols_to_extract.append(eaf[1])
     
-    if verbose: log.write(" -Extract statistics of selected variants from "+label[1]+" : ",",".join(cols_to_extract) )
+    log.write(" -Extract statistics of selected variants from "+label[1]+" : ",",".join(cols_to_extract), verbose=verbose )
     if type(path2) is Sumstats:
         sumstats = path2.data[cols_to_extract].copy()
     elif type(path2) is pd.DataFrame:
@@ -353,7 +353,7 @@ def compare_effect(path1,
         sumstats = drop_duplicate_and_na(sumstats, sort_by="P_2", log=log, verbose=verbose)
     sumstats.drop("P_2",axis=1,inplace=True)
 
-    if verbose: log.write(" -Merging "+label[1]+" effect information...")
+    log.write(" -Merging "+label[1]+" effect information...", verbose=verbose)
     sig_list_merged = pd.merge(sig_list_merged,sumstats,
                                left_on="SNPID",right_on="SNPID",
                                how="left")
@@ -361,7 +361,7 @@ def compare_effect(path1,
     sig_list_merged.set_index("SNPID",inplace=True)
 
     ################ 16 update sumstats1
-    if verbose: log.write(" -Updating missing information for "+label[0]+" ...")
+    log.write(" -Updating missing information for "+label[0]+" ...", verbose=verbose)
     if type(path1) is Sumstats:
         sumstats = path1.data[[cols_name_list_1[0],cols_name_list_1[1]]].copy()
     elif type(path1) is pd.DataFrame:
@@ -383,7 +383,7 @@ def compare_effect(path1,
     sig_list_merged.update(sumstats)
     
     ################# 17 update sumstats2
-    if verbose: log.write(" -Updating missing information for "+label[1]+" ...")
+    log.write(" -Updating missing information for "+label[1]+" ...", verbose=verbose)
     if type(path2) is Sumstats:
         sumstats = path2.data[[cols_name_list_2[0],cols_name_list_2[1]]].copy()
     elif type(path2) is pd.DataFrame:
@@ -406,15 +406,15 @@ def compare_effect(path1,
     sig_list_merged.update(sumstats)
 
     if scaled1 ==True :
-        if verbose:log.write(" -Sumstats -log10(P) values are being converted to P...")
+        log.write(" -Sumstats -log10(P) values are being converted to P...", verbose=verbose)
         sig_list_merged["P_1"] = np.power(10,-sig_list_merged["P_1"])
     if scaled2 ==True :
-        if verbose:log.write(" -Sumstats -log10(P) values are being converted to P...")
+        log.write(" -Sumstats -log10(P) values are being converted to P...", verbose=verbose)
         sig_list_merged["P_2"] = np.power(10,-sig_list_merged["P_2"])
     ####
 #################################################################################
     ############## 18 init indicator
-    if verbose: log.write(" -Assigning indicator  ...")
+    log.write(" -Assigning indicator  ...", verbose=verbose)
     # 0-> 0
     # 1 -> sig in sumstats1
     # 2 -> sig in sumsatts2
@@ -428,7 +428,7 @@ def compare_effect(path1,
         sig_list_merged["POS"]=np.max(sig_list_merged[["POS_1","POS_2"]], axis=1).astype(int)
         sig_list_merged.drop(labels=['CHR_1', 'CHR_2','POS_1', 'POS_2'], axis=1,inplace=True)
     
-    if verbose: log.write(" -Aligning "+label[1]+" EA with "+label[0]+" EA ...")
+    log.write(" -Aligning "+label[1]+" EA with "+label[0]+" EA ...", verbose=verbose)
     ############### 19 align allele effect with sumstats 1
     sig_list_merged["EA_1"]=sig_list_merged["EA_1"].astype("string")
     sig_list_merged["EA_2"]=sig_list_merged["EA_2"].astype("string")
@@ -476,16 +476,16 @@ def compare_effect(path1,
     
     # checking effect allele matching
     nonmatch = np.nansum(sig_list_merged["EA_1"] != sig_list_merged["EA_2_aligned"])
-    if verbose: log.write(" -Aligned all EAs in {} with EAs in {} ...".format(label[1],label[0]))
+    log.write(" -Aligned all EAs in {} with EAs in {} ...".format(label[1],label[0]), verbose=verbose)
     if nonmatch>0:
-        if verbose: log.write(" -Warning: Alleles for {} variants do not match...".format(nonmatch))
+        log.warning("Alleles for {} variants do not match...".format(nonmatch))
     if allele_match==True:
         if nonmatch>0:
             sig_list_merged = sig_list_merged.loc[sig_list_merged["EA_1"] == sig_list_merged["EA_2_aligned"]]
         else:
-            if verbose: log.write(" -No variants with EA not matching...")
+            log.write(" -No variants with EA not matching...", verbose=verbose)
     if fdr==True:
-        if verbose: log.write(" -Using FDR...")
+        log.write(" -Using FDR...", verbose=verbose)
         #sig_list_merged["P_1"] = fdrcorrection(sig_list_merged["P_1"])[1]
         #sig_list_merged["P_2"] = fdrcorrection(sig_list_merged["P_2"])[1]
         sig_list_merged["P_1"] =ss.false_discovery_control(sig_list_merged["P_1"])
@@ -495,41 +495,41 @@ def compare_effect(path1,
     ## winner's curse correction using aligned beta
     if mode=="beta":
         if wc_correction == "all":
-            if verbose: log.write(" -Correcting BETA for winner's curse with threshold at {} for all variants...".format(sig_level))
+            log.write(" -Correcting BETA for winner's curse with threshold at {} for all variants...".format(sig_level), verbose=verbose)
             sig_list_merged["EFFECT_1_RAW"] = sig_list_merged["EFFECT_1"].copy()
             sig_list_merged["EFFECT_2_aligned_RAW"] = sig_list_merged["EFFECT_2_aligned"].copy()
             
-            if verbose: log.write("  -Correcting BETA for {} variants in sumstats1...".format(sum(~sig_list_merged["EFFECT_1"].isna())))
+            log.write("  -Correcting BETA for {} variants in sumstats1...".format(sum(~sig_list_merged["EFFECT_1"].isna())), verbose=verbose)
             sig_list_merged["EFFECT_1"] = sig_list_merged[["EFFECT_1_RAW","SE_1"]].apply(lambda x: wc_correct(x[0],x[1],sig_level),axis=1)
 
-            if verbose: log.write("  -Correcting BETA for {} variants in sumstats2...".format(sum(~sig_list_merged["EFFECT_2_aligned"].isna())))
+            log.write("  -Correcting BETA for {} variants in sumstats2...".format(sum(~sig_list_merged["EFFECT_2_aligned"].isna())), verbose=verbose)
             sig_list_merged["EFFECT_2_aligned"] = sig_list_merged[["EFFECT_2_aligned_RAW","SE_2"]].apply(lambda x: wc_correct(x[0],x[1],sig_level),axis=1)
         
         elif wc_correction == "sig" :
-            if verbose: log.write(" - Correcting BETA for winner's curse with threshold at {} for significant variants...".format(sig_level))
+            log.write(" - Correcting BETA for winner's curse with threshold at {} for significant variants...".format(sig_level), verbose=verbose)
             sig_list_merged["EFFECT_1_RAW"] = sig_list_merged["EFFECT_1"].copy()
             sig_list_merged["EFFECT_2_aligned_RAW"] = sig_list_merged["EFFECT_2_aligned"].copy()
-            if verbose: log.write("  -Correcting BETA for {} variants in sumstats1...".format(sum(sig_list_merged["P_1"]<sig_level)))
+            log.write("  -Correcting BETA for {} variants in sumstats1...".format(sum(sig_list_merged["P_1"]<sig_level)), verbose=verbose)
             sig_list_merged.loc[sig_list_merged["P_1"]<sig_level, "EFFECT_1"]         = sig_list_merged.loc[sig_list_merged["P_1"]<sig_level, ["EFFECT_1_RAW","SE_1"]].apply(lambda x: wc_correct_test(x[0],x[1],sig_level),axis=1)
-            if verbose: log.write("  -Correcting BETA for {} variants in sumstats2...".format(sum(sig_list_merged["P_2"]<sig_level)))
+            log.write("  -Correcting BETA for {} variants in sumstats2...".format(sum(sig_list_merged["P_2"]<sig_level)), verbose=verbose)
             sig_list_merged.loc[sig_list_merged["P_2"]<sig_level, "EFFECT_2_aligned"] = sig_list_merged.loc[sig_list_merged["P_2"]<sig_level, ["EFFECT_2_aligned_RAW","SE_2"]].apply(lambda x: wc_correct_test(x[0],x[1],sig_level),axis=1)
         
         elif wc_correction == "sumstats1" :
-            if verbose: log.write(" - Correcting BETA for winner's curse with threshold at {} for significant variants in sumstats1...".format(sig_level))
+            log.write(" - Correcting BETA for winner's curse with threshold at {} for significant variants in sumstats1...".format(sig_level), verbose=verbose)
             sig_list_merged["EFFECT_1_RAW"] = sig_list_merged["EFFECT_1"].copy()
-            if verbose: log.write("  -Correcting BETA for {} variants in sumstats1...".format(sum(sig_list_merged["P_1"]<sig_level)))
+            log.write("  -Correcting BETA for {} variants in sumstats1...".format(sum(sig_list_merged["P_1"]<sig_level)), verbose=verbose)
             sig_list_merged.loc[sig_list_merged["P_1"]<sig_level, "EFFECT_1"]         = sig_list_merged.loc[sig_list_merged["P_1"]<sig_level, ["EFFECT_1_RAW","SE_1"]].apply(lambda x: wc_correct_test(x[0],x[1],sig_level),axis=1)
             
         elif wc_correction == "sumstats2" :
-            if verbose: log.write(" - Correcting BETA for winner's curse with threshold at {} for significant variants in sumstats2...".format(sig_level))
+            log.write(" - Correcting BETA for winner's curse with threshold at {} for significant variants in sumstats2...".format(sig_level), verbose=verbose)
             sig_list_merged["EFFECT_2_aligned_RAW"] = sig_list_merged["EFFECT_2_aligned"].copy()
-            if verbose: log.write("  -Correcting BETA for {} variants in sumstats2...".format(sum(sig_list_merged["P_2"]<sig_level)))
+            log.write("  -Correcting BETA for {} variants in sumstats2...".format(sum(sig_list_merged["P_2"]<sig_level)), verbose=verbose)
             sig_list_merged.loc[sig_list_merged["P_2"]<sig_level, "EFFECT_2_aligned"] = sig_list_merged.loc[sig_list_merged["P_2"]<sig_level, ["EFFECT_2_aligned_RAW","SE_2"]].apply(lambda x: wc_correct_test(x[0],x[1],sig_level),axis=1)
 
     ########################## Het test############################################################
     ## heterogeneity test
     if (is_q is True):
-        if verbose: log.write(" -Calculating Cochran's Q statistics and peform chisq test...")
+        log.write(" -Calculating Cochran's Q statistics and peform chisq test...", verbose=verbose)
         if mode=="beta" or mode=="BETA" or mode=="Beta":
             sig_list_merged = test_q(sig_list_merged,"EFFECT_1","SE_1","EFFECT_2_aligned","SE_2",q_level=q_level,is_q_mc=is_q_mc, log=log, verbose=verbose)
         else:
@@ -538,19 +538,19 @@ def compare_effect(path1,
     ######################### save ###############################################################
     ## save the merged data
     save_path = label[0]+"_"+label[1]+"_beta_sig_list_merged.tsv"
-    if verbose: log.write(" -Saving the merged data to:",save_path)
+    log.write(" -Saving the merged data to:",save_path, verbose=verbose)
     sig_list_merged.to_csv(save_path,"\t")
     
     ########################## maf_threshold#############################################################
     if (len(eaf)>0) and (maf_level is not None):
         both_eaf_clear =  (sig_list_merged["EAF_1"]>maf_level)&(sig_list_merged["EAF_1"]<1-maf_level)&(sig_list_merged["EAF_2"]>maf_level)&(sig_list_merged["EAF_2"]<1-maf_level)
-        if verbose: log.write(" -Exclude "+str(len(sig_list_merged) -sum(both_eaf_clear))+ " variants with maf <",maf_level)
+        log.write(" -Exclude "+str(len(sig_list_merged) -sum(both_eaf_clear))+ " variants with maf <",maf_level, verbose=verbose)
         sig_list_merged = sig_list_merged.loc[both_eaf_clear,:]
     # heterogeneity summary
     if (is_q is True):
-        if verbose: log.write(" -Significant het:" ,len(sig_list_merged.loc[sig_list_merged["HetP"]<0.05,:]))
-        if verbose: log.write(" -All sig:" ,len(sig_list_merged))
-        if verbose: log.write(" -Het rate:" ,len(sig_list_merged.loc[sig_list_merged["HetP"]<0.05,:])/len(sig_list_merged))   
+        log.write(" -Significant het:" ,len(sig_list_merged.loc[sig_list_merged["HetP"]<0.05,:]), verbose=verbose)
+        log.write(" -All sig:" ,len(sig_list_merged), verbose=verbose)
+        log.write(" -Het rate:" ,len(sig_list_merged.loc[sig_list_merged["HetP"]<0.05,:])/len(sig_list_merged), verbose=verbose)   
     
     # extract group
     if include_all==True:
@@ -568,13 +568,13 @@ def compare_effect(path1,
         sum2only["Edge_color"]="none"
         both["Edge_color"]="none"
 
-    if verbose: log.write(" -Identified "+str(len(sum0)) + " variants which are not significant in " + label[3]+".")
-    if verbose: log.write(" -Identified "+str(len(sum1only)) + " variants which are only significant in " + label[0]+".")
-    if verbose: log.write(" -Identified "+str(len(sum2only)) + " variants which are only significant in " + label[1]+".")
-    if verbose: log.write(" -Identified "+str(len(both)) + " variants which are significant in " + label[2] + ".")
+    log.write(" -Identified "+str(len(sum0)) + " variants which are not significant in " + label[3]+".", verbose=verbose)
+    log.write(" -Identified "+str(len(sum1only)) + " variants which are only significant in " + label[0]+".", verbose=verbose)
+    log.write(" -Identified "+str(len(sum2only)) + " variants which are only significant in " + label[1]+".", verbose=verbose)
+    log.write(" -Identified "+str(len(both)) + " variants which are significant in " + label[2] + ".", verbose=verbose)
     
     ##plot########################################################################################
-    if verbose: log.write("Creating the scatter plot for effect sizes comparison...")
+    log.write("Creating the scatter plot for effect sizes comparison...", verbose=verbose)
     #plt.style.use("ggplot")
     sns.set_style("ticks")
     fig,ax = plt.subplots(**plt_args) 
@@ -721,7 +721,7 @@ def compare_effect(path1,
             
             # estimate se for r
             if r_se==True:
-                if verbose:log.write(" -Estimating SE for rsq using Jackknife method.")
+                log.write(" -Estimating SE for rsq using Jackknife method.", verbose=verbose)
                 r_se_jackknife = jackknife_r(sig_list_merged)
                 r_se_jackknife_string = " ({:.2f})".format(r_se_jackknife)
             else:
@@ -731,19 +731,19 @@ def compare_effect(path1,
             r_se_jackknife_string= ""
 
         #### calculate p values based on selected value , default = 0 
-        if verbose:log.write(" -Calculating p values based on given null slope :",null_beta)
+        log.write(" -Calculating p values based on given null slope :",null_beta, verbose=verbose)
         t_score = (reg[0]-null_beta) / reg[4]
         degree = len(sig_list_merged.dropna())-2
         p =  reg[3]
         #ss.t.sf(abs(t_score), df=degree)*2
-        if verbose:log.write(" -Beta = ", reg[0])
-        if verbose:log.write(" -Beta_se = ", reg[4])
-        #if verbose:log.write(" -H0 beta = ", null_beta, ", recalculated p = ", "{:.2e}".format(p))
-        if verbose:log.write(" -H0 beta =  0",", default p = ", "{:.2e}".format(reg[3]))
-        if verbose:log.write(" -Peason correlation coefficient =  ", "{:.2f}".format(reg[2]))
-        if verbose:log.write(" -r2 =  ", "{:.2f}".format(reg[2]**2))
+        log.write(" -Beta = ", reg[0], verbose=verbose)
+        log.write(" -Beta_se = ", reg[4], verbose=verbose)
+        #log.write(" -H0 beta = ", null_beta, ", recalculated p = ", "{:.2e}".format(p), verbose=verbose)
+        log.write(" -H0 beta =  0",", default p = ", "{:.2e}".format(reg[3]), verbose=verbose)
+        log.write(" -Peason correlation coefficient =  ", "{:.2f}".format(reg[2]), verbose=verbose)
+        log.write(" -r2 =  ", "{:.2f}".format(reg[2]**2), verbose=verbose)
         if r_se==True:
-            if verbose:log.write(" -R se (jackknife) = {:.2e}".format(r_se_jackknife))
+            log.write(" -R se (jackknife) = {:.2e}".format(r_se_jackknife), verbose=verbose)
 
         if reg[0] > 0:
             #if regression coeeficient >0 : auxiliary line slope = 1
@@ -866,15 +866,7 @@ def compare_effect(path1,
     gc.collect()
 
     save_figure(fig, save, keyword="esc",save_args=save_args, log=log, verbose=verbose)
-    
-    #if save:
-    #    if verbose: log.write("Saving plot:")
-    #    if save==True:
-    #        fig.savefig("./{}_{}_effect_comparison_plot.png".format(label[0],label[1]),bbox_inches="tight",**save_args)
-    #        log.write(" -Saved to "+ "./{}_{}_effect_comparison_plot.png".format(label[0],label[1]) + " successfully!" )
-    #    else:
-    #        fig.savefig(save,bbox_inches="tight",**save_args)
-    #        log.write(" -Saved to "+ save + " successfully!" )
+
     
     return [sig_list_merged, fig,log]
 
@@ -902,10 +894,10 @@ def test_q(df,beta1,se1,beta2,se2,q_level=0.05,is_q_mc=False, log=Log(), verbose
     df["Edge_color"]="white"
 
     if is_q_mc=="fdr":
-        if verbose: log.write(" -FDR correction applied...")
+        log.write(" -FDR correction applied...", verbose=verbose)
         df[pq] = ss.false_discovery_control(df[pq])
     elif is_q_mc=="bon":
-        if verbose: log.write(" -Bonferroni correction applied...")
+        log.write(" -Bonferroni correction applied...", verbose=verbose)
         df[pq] = df[pq] * len(df[pq])
 
     df.loc[df[pq]<q_level,"Edge_color"]="black"
@@ -958,5 +950,5 @@ def drop_duplicate_and_na(df,snpid="SNPID",sort_by=False,log=Log(),verbose=True)
     df.drop_duplicates(subset=[snpid], keep='first', inplace=True) 
     length_after= len(df)
     if length_before !=  length_after:
-        if verbose: log.write(" -Dropped {} duplicates or NAs...".format(length_before - length_after))
+        log.write(" -Dropped {} duplicates or NAs...".format(length_before - length_after), verbose=verbose)
     return df

gwaslab/viz_plot_miamiplot2.py

@@ -38,6 +38,7 @@ from gwaslab.g_Sumstats import Sumstats
 from gwaslab.viz_aux_save_figure import save_figure
 from gwaslab.viz_plot_mqqplot import mqqplot
 from gwaslab.g_version import _get_version
+
 def plot_miami2( 
           path1=None,
           path2=None,
@@ -86,7 +87,7 @@ def plot_miami2(
           log=Log(),
           **mqq_args
           ):
-    
+    log.write("Start to create miami plot {}:".format(_get_version()), verbose=verbose)
     ## figuring arguments ###########################################################################################################
     # figure columns to use
     if scaled == True:
@@ -98,6 +99,7 @@ def plot_miami2(
             cols = ["CHR","POS","MLOG10P"]
         else:
             cols = ["CHR","POS","P"]
+
     if cols1 is None:
         cols1 = cols.copy()
     if cols2 is None:
@@ -151,9 +153,8 @@ def plot_miami2(
     fig_args, scatter_args = _figure_args_for_vector_plot(save, fig_args, scatter_args)
 
     # add suffix if ids are the same
-    id1, id2, mqq_args1, mqq_args2 = _solve_id_contradictory(id0, id1, id2, mqq_args1, mqq_args2)
-    
-    if verbose: log.write("Start to plot miami plot {}:".format(_get_version()))
+    id1_1, id2_2, mqq_args1, mqq_args2 = _solve_id_contradictory(id0, id1, id2, mqq_args1, mqq_args2)
+
     if dpi!=100:
         fig_args["dpi"] = dpi
     if xtickpad is None:
@@ -176,6 +177,7 @@ def plot_miami2(
             titles_pad_adjusted[0]= 1 + titles_pad[0]
         if "anno2" in mqq_args.keys():
             titles_pad_adjusted[1]=  - titles_pad[1]
+
     if merged_sumstats is None:
     ## load sumstats1 ###########################################################################################################
         sumstats1 = _figure_type_load_sumstats(name="Sumstats1", 
@@ -198,8 +200,8 @@ def plot_miami2(
     else:
         cols1[2] += suffixes[0]
         cols2[2] += suffixes[1]
-        sumstats1 = merged_sumstats.loc[:,cols1].copy()
-        sumstats2 = merged_sumstats.loc[:,cols2].copy()
+        sumstats1 = merged_sumstats[cols1].copy()
+        sumstats2 = merged_sumstats[cols2].copy()
 
     ## rename and quick fix ###########################################################################################################
     renaming_dict1 = {cols1[0]:"CHR",cols1[1]:"POS",cols1[2]:"P"}
@@ -217,7 +219,7 @@ def plot_miami2(
     ## create merge index ###########################################################################################################
     sumstats1 = _quick_add_tchrpos(sumstats1,large_number=large_number, dropchrpos=False, verbose=verbose, log=log)
     sumstats2 = _quick_add_tchrpos(sumstats2,large_number=large_number, dropchrpos=False, verbose=verbose, log=log)
-    if verbose: log.write(" -Merging sumstats using chr and pos...")
+    log.write(" -Merging sumstats using chr and pos...",verbose=verbose)
     
     ###### merge #####################################################################################################
     merged_sumstats = _quick_merge_sumstats(sumstats1=sumstats1,sumstats2=sumstats2)
@@ -231,7 +233,9 @@ def plot_miami2(
                                                           drop_chr_start=False)
     
     # P_1  scaled_P_1  P_2  scaled_P_2  TCHR+POS CHR POS    
-    
+    log.write(" -Columns in merged sumstats: {}".format(",".join(merged_sumstats.columns)), verbose=verbose)
+
+
     del(sumstats1)
     del(sumstats2)
     garbage_collect.collect()
@@ -243,13 +247,14 @@ def plot_miami2(
         plt.subplots_adjust(hspace=region_hspace)    
     else:
         fig, ax1, ax5 = figax
-
+    
+    log.write("Start to create Manhattan plot for sumstats1...", verbose=verbose)
     fig,log = mqqplot(merged_sumstats,
                       chrom="CHR",
                       pos="POS",
                       p="P_1",
                       mlog10p="scaled_P_1",
-                      snpid=id1,
+                      snpid=id1_1,
                       scaled=scaled1,
                       log=log, 
                       mode=mode,
@@ -260,15 +265,16 @@ def plot_miami2(
                       _if_quick_qc=False,
                       **mqq_args1
                      )
+    log.write("Finished creating Manhattan plot for sumstats1".format(_get_version()), verbose=verbose)
 
-
+    log.write("Start to create Manhattan plot for sumstats2...", verbose=verbose)
     fig,log = mqqplot(merged_sumstats,
                       chrom="CHR",
                       pos="POS",
                       p="P_2",
                       mlog10p="scaled_P_2",
                       scaled=scaled2,
-                      snpid=id2,
+                      snpid=id2_2,
                       log=log, 
                       mode=mode,
                       figax=(fig,ax5),
@@ -277,7 +283,8 @@ def plot_miami2(
                        _invert=True,
                       _if_quick_qc=False,
                      **mqq_args2)
-    
+    log.write("Finished creating Manhattan plot for sumstats2".format(_get_version()), verbose=verbose)
+
     if same_ylim==True:
         ylim1_converted = ax1.get_ylim()
         ylim2_converted = ax5.get_ylim()
@@ -285,8 +292,6 @@ def plot_miami2(
             ax5.set_ylim(ylim1_converted)
         else:
             ax1.set_ylim(ylim2_converted)
-    
-    
     #####################################################################################################################    
     
     ax5.set_xlabel("")
@@ -316,7 +321,7 @@ def plot_miami2(
 
     garbage_collect.collect()
     
-    if verbose: log.write("Finished creating miami plot successfully")
+    log.write("Finished creating miami plot successfully", verbose=verbose)
     #Return matplotlib figure object #######################################################################################
     return fig, log
 
@@ -337,24 +342,27 @@ def _sort_args_to_12(mqq_args):
     return mqq_args1, mqq_args2
 
 def _solve_id_contradictory(id0, id1, id2, mqq_args1, mqq_args2):
-    if id1 is not None and id2 is not None:
+    if (id1 is not None) and (id2 is not None):
         if id1 == id2:
             id1_1 = id1 + "_1"
             id2_2 = id2 + "_2"
             if "anno" in mqq_args1.keys():
                 if mqq_args1["anno"] == id1:
                     mqq_args1["anno"] = id1_1
-            if "anno" in mqq_args1.keys():
-                if mqq_args1["anno"] == id2:
-                    mqq_args1["anno"] = id2_2
+            if "anno" in mqq_args2.keys():
+                if mqq_args2["anno"] == id2:
+                    mqq_args2["anno"] = id2_2
         else:
             id1_1 = id1
             id2_2 = id2
+    
     if id1 is None:
         id1_1 = id0
+
     if id2 is None:
         id2_2 = id0
-    return id1_1, id2_2, mqq_args1, mqq_args2
+
+    return (id1_1, id2_2, mqq_args1, mqq_args2)
 
 def _figure_args_for_vector_plot(save, fig_args, scatter_kwargs ):
     if save is not None:
@@ -379,19 +387,19 @@ def _set_spine_visibility(ax1,ax5):
 
 def _figure_type_load_sumstats(name, path, sep, cols, readcsv_args, loadmode, log, verbose):
     if type(path) is str:
-        if verbose: log.write(" -Loading {} ({} mode): {}".format(name, loadmode, path))
-    if verbose: log.write(" -Obtaining {} CHR, POS, P and annotation from: {}".format(name, cols))
+        log.write(" -Loading {} ({} mode): {}".format(name, loadmode, path), verbose=verbose)
+    log.write(" -Obtaining {} CHR, POS, P and annotation from: {}".format(name, cols), verbose=verbose)
     
     if loadmode=="pickle":
         sumstats = load_data_from_pickle(path,usecols=cols) 
     else:
         if type(path) is Sumstats:
-            if verbose: log.write(" -Loading {} from gwaslab.Sumstats Object".format(name))
+            log.write(" -Loading {} from gwaslab.Sumstats Object".format(name), verbose=verbose)
             sumstats = path.data[cols].copy()
         elif type(path) is pd.DataFrame:
-            if verbose: log.write(" -Loading {} from pandas.DataFrame Object".format(name))
+            log.write(" -Loading {} from pandas.DataFrame Object".format(name), verbose=verbose)
             sumstats = path[cols].copy()
         else:
-            if verbose: log.write(" -Loading {} from tabular files".format(name))
+            log.write(" -Loading {} from tabular files".format(name), verbose=verbose)
             sumstats=pd.read_table(path,sep=sep,usecols=cols,dtype={cols[0]:"string",cols[1]:"Int64",cols[2]:"float64"},**readcsv_args)
     return sumstats