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

gwaslab/util_in_calculate_power.py

@@ -21,24 +21,23 @@ def get_power(
               log=Log(),
               verbose=True
              ):
-    if verbose: log.write(" Start to calculate statistical power...")
+    log.write(" Start to calculate statistical power...", verbose=verbose)
     if mode=="b":
-        if verbose: 
-            log.write(" -Input settings (b mode):")
-            log.write("  -Number of cases:{}".format(ncase))
-            log.write("  -Number of controls:{}".format(ncontrol))
-            if genotype_rr is not None:
-                log.write("  -Risk allele RR:{:.3f}".format(genotype_rr))
-            elif genotype_or is not None:
-                log.write("  -Risk allele OR:{:.3f}".format(genotype_or))
-            elif beta is not None:
-                log.write("  -Risk allele beta:{:.3f}".format(beta))
-            else:
-                genotype_rr = 0.1
-                log.write("  -Risk allele RR:{:.3f}".format(genotype_rr))
-            log.write("  -Disease prevalence:{:.3f}".format(prevalence))
-            log.write("  -Risk allele frequency: {:.3f}".format(daf))
-            log.write("  -Significance level: {:.3e}".format(sig_level))
+        log.write(" -Input settings (b mode):", verbose=verbose)
+        log.write("  -Number of cases:{}".format(ncase), verbose=verbose)
+        log.write("  -Number of controls:{}".format(ncontrol), verbose=verbose)
+        if genotype_rr is not None:
+            log.write("  -Risk allele RR:{:.3f}".format(genotype_rr), verbose=verbose)
+        elif genotype_or is not None:
+            log.write("  -Risk allele OR:{:.3f}".format(genotype_or), verbose=verbose)
+        elif beta is not None:
+            log.write("  -Risk allele beta:{:.3f}".format(beta), verbose=verbose)
+        else:
+            genotype_rr = 0.1
+            log.write("  -Risk allele RR:{:.3f}".format(genotype_rr), verbose=verbose)
+        log.write("  -Disease prevalence:{:.3f}".format(prevalence), verbose=verbose)
+        log.write("  -Risk allele frequency: {:.3f}".format(daf), verbose=verbose)
+        log.write("  -Significance level: {:.3e}".format(sig_level), verbose=verbose)
         # Skol, A. D., Scott, L. J., Abecasis, G. R., & Boehnke, M. (2006). Joint analysis is more efficient than replication-based analysis for two-stage genome-wide association studies. Nature genetics, 38(2), 209-213.
         aaf = daf**2
         abf = 2 * (daf) * (1 - daf)
@@ -56,11 +55,11 @@ def get_power(
                 # https://jamanetwork.com/journals/jama/fullarticle/188182
         
             if or_to_rr ==False:
-                if verbose: log.write(" -Alogorithm: Skol, Andrew D., et al. Nature genetics 38.2 (2006): 209-213....")
-                if verbose: log.write(" -GRR is approximated using OR. For prevalence < 10%, GRR is very similar to OR....")
+                log.write(" -Alogorithm: Skol, Andrew D., et al. Nature genetics 38.2 (2006): 209-213....", verbose=verbose)
+                log.write(" -GRR is approximated using OR. For prevalence < 10%, GRR is very similar to OR....", verbose=verbose)
             else:
-                if verbose: log.write(" -OR is converted to GRR using base prevalence: {}".format(prevalence))
-                if verbose: log.write(" -Alogorithm: Zhang, J., & Kai, F. Y. (1998). What's the relative risk?: A method of correcting the odds ratio in cohort studies of common outcomes. Jama, 280(19), 1690-1691.....")
+                log.write(" -OR is converted to GRR using base prevalence: {}".format(prevalence), verbose=verbose)
+                log.write(" -Alogorithm: Zhang, J., & Kai, F. Y. (1998). What's the relative risk?: A method of correcting the odds ratio in cohort studies of common outcomes. Jama, 280(19), 1690-1691.....", verbose=verbose)
             
         # additive
         x = [ 2*genotype_rr-1, genotype_rr, 1 ] 
@@ -68,19 +67,19 @@ def get_power(
         aap= x[0] * prevalence / (x[0]*aaf + x[1]*abf + x[2]*bbf)
         abp= x[1] * prevalence / (x[0]*aaf + x[1]*abf + x[2]*bbf)
         bbp= x[2] * prevalence / (x[0]*aaf + x[1]*abf + x[2]*bbf)
-        if verbose: log.write("Probability of disease :")
-        if verbose: log.write(" - Individuals with AA genotype: {:.3f}".format(aap))
-        if verbose: log.write(" - Individuals with AB genotype: {:.3f}".format(abp))
-        if verbose: log.write(" - Individuals with BB genotype: {:.3f}".format(bbp))
+        log.write("Probability of disease :", verbose=verbose)
+        log.write(" - Individuals with AA genotype: {:.3f}".format(aap), verbose=verbose)
+        log.write(" - Individuals with AB genotype: {:.3f}".format(abp), verbose=verbose)
+        log.write(" - Individuals with BB genotype: {:.3f}".format(bbp), verbose=verbose)
         
         pcase= (aap * aaf + abp * abf*0.5) / prevalence
         pcontrol=((1-aap )* aaf + (1-abp )* abf*0.5) / (1 - prevalence)
 
         vcase = pcase *(1-pcase)
         vcontrol =pcontrol *(1-pcontrol)
-        if verbose: log.write("Expected risk allele frequency:")
-        if verbose: log.write(" - In cases: {:.3f}".format(pcase))
-        if verbose: log.write(" - In controls: {:.3f}".format(pcontrol))
+        log.write("Expected risk allele frequency:", verbose=verbose)
+        log.write(" - In cases: {:.3f}".format(pcase), verbose=verbose)
+        log.write(" - In controls: {:.3f}".format(pcontrol), verbose=verbose)
 
         num= (pcase - pcontrol)
         den= np.sqrt( (vcase/ncase +  vcontrol/ncontrol)*0.5 )
@@ -88,22 +87,22 @@ def get_power(
 
         c = ss.norm.isf(sig_level/2)
         power = 1 - ss.norm.cdf(c-u) + ss.norm.cdf(-c-u)
-        if verbose: log.write("Expected power: {:.3f}".format(power))
+        log.write("Expected power: {:.3f}".format(power), verbose=verbose)
 
     elif mode=="q":
         if beta is None:
             beta = 0.1
-        if verbose:
-            log.write(" -Input settings (q mode):")
-            log.write("  -Significance level: {}".format(sig_level))
-            log.write("  -EAF: {}".format(eaf))
-            log.write("  -BETA: {}".format(beta))
-            log.write("  -N: {}".format(n))
-            log.write("  -SNPR2: {}".format(2*eaf*(1-eaf)*(beta**2)))
+
+        log.write(" -Input settings (q mode):", verbose=verbose)
+        log.write("  -Significance level: {}".format(sig_level), verbose=verbose)
+        log.write("  -EAF: {}".format(eaf), verbose=verbose)
+        log.write("  -BETA: {}".format(beta), verbose=verbose)
+        log.write("  -N: {}".format(n), verbose=verbose)
+        log.write("  -SNPR2: {}".format(2*eaf*(1-eaf)*(beta**2)), verbose=verbose)
         c = ss.chi2.isf(sig_level,df=1)
         NCP = n * 2*eaf*(1-eaf)*(beta**2)/vary
         power = 1 - ss.ncx2.cdf(c, df=1, nc=NCP)
-    if verbose: log.write("Finished calculating statistical power.")
+    log.write("Finished calculating statistical power.", verbose=verbose)
     return power
 
 def get_beta(
@@ -137,11 +136,11 @@ def get_beta(
             eafs = np.linspace(eaf_range[1],eaf_range[0],n_matrix)
             betas =  np.linspace(beta_range[0],beta_range[1],n_matrix)
             
-            if verbose: log.write(" -Updating eaf-beta matrix...")
+            log.write(" -Updating eaf-beta matrix...", verbose=verbose)
             for i in range(n_matrix):
                     eaf_beta_matrix[i,] = calculate_power_single(beta=betas,eaf=eafs[i],n=n,sig_level=sig_level,vary=vary)
             
-            if verbose: log.write(" -Extracting eaf-beta combinations with power = {}...".format(t))
+            log.write(" -Extracting eaf-beta combinations with power = {}...".format(t), verbose=verbose)
             i,j=1,1
             eaf_beta = []
             while i<n_matrix-1 and j<n_matrix-1:
@@ -207,11 +206,11 @@ def get_beta_binary(
         eafs = np.linspace(eaf_range[1],eaf_range[0],n_matrix)
         betas =  np.linspace(beta_range[0],beta_range[1],n_matrix)
         
-        if verbose: log.write(" -Updating eaf-beta matrix...")
+        log.write(" -Updating eaf-beta matrix...", verbose=verbose)
         if or_to_rr ==False:
-            if verbose: log.write(" -GRR is approximated using OR. For prevalence < 10%, GRR is very similar to OR....")
+            log.write(" -GRR is approximated using OR. For prevalence < 10%, GRR is very similar to OR....", verbose=verbose)
         else:
-            if verbose: log.write(" -OR is converted to GRR using base prevalence: {}".format(prevalence))
+            log.write(" -OR is converted to GRR using base prevalence: {}".format(prevalence), verbose=verbose)
         
         for i in range(n_matrix):
                 eaf_beta_matrix[i,] = calculate_power_single(beta=betas,
@@ -222,7 +221,7 @@ def get_beta_binary(
                                                                 sig_level=sig_level,
                                                                 or_to_rr=or_to_rr)
         
-        if verbose: log.write(" -Extracting eaf-beta combinations with power = {}...".format(t))
+        log.write(" -Extracting eaf-beta combinations with power = {}...".format(t), verbose=verbose)
         i,j=1,1
         eaf_beta = []
         while i<n_matrix-1 and j<n_matrix-1:

gwaslab/util_in_convert_h2.py

@@ -65,7 +65,7 @@ def _get_per_snp_r2(sumstats,
            adjuested=False,
            verbose=True):
     # Pierce, B. L., Ahsan, H., & VanderWeele, T. J. (2011). Power and instrument strength requirements for Mendelian randomization studies using multiple genetic variants. International journal of epidemiology, 40(3), 740-752.
-    if verbose: log.write("Start to calculate per-SNP heritibility...")
+    log.write("Start to calculate per-SNP heritibility...", verbose=verbose)
     if type(k) is int or type(k) is float:
        pass 
     elif k =="all":
@@ -81,18 +81,18 @@ def _get_per_snp_r2(sumstats,
             # Var(e) = betase**2 * 2 * N * MAF * (1-MAF)
             # r2 = Var(beta * X) / Var(y)
 
-            if verbose: log.write(" -Calculating per-SNP rsq by 2 * (BETA**2) * AF * (1-AF) / Var(y)...")
+            log.write(" -Calculating per-SNP rsq by 2 * (BETA**2) * AF * (1-AF) / Var(y)...", verbose=verbose)
             sumstats["_VAR(BETAX)"] = 2*(sumstats[beta]**2)*sumstats[af]*(1-sumstats[af])
             
             if type(vary) is int or type(vary) is float:
-                if verbose: log.write(" -Var(y) is provided: {}...".format(vary))
+                log.write(" -Var(y) is provided: {}...".format(vary), verbose=verbose)
                 sumstats["SNPR2"] = sumstats["_VAR(BETAX)"] / vary
             elif vary=="se":
-                if verbose: log.write(" -Var(y) is estimated from VAR(BETA * X), N, MAF, SE: {}...".format(vary))
+                log.write(" -Var(y) is estimated from VAR(BETA * X), N, MAF, SE: {}...".format(vary), verbose=verbose)
                 sumstats["_SIGMA2"] = sumstats[se]**2 * 2*(sumstats[n])*sumstats[af]*(1-sumstats[af])
                 sumstats["SNPR2"] = sumstats["_VAR(BETAX)"] / (sumstats["_SIGMA2"] + sumstats["_VAR(BETAX)"]) 
         else:
-            if verbose: log.write(" -Warning: Not enough informationfor calculation.")
+            log.warning("Not enough information for calculation.")
     
     if mode=="b":
         if ncase not in sumstats.columns:
@@ -117,11 +117,11 @@ def _get_per_snp_r2(sumstats,
     else:
         snpr2 = "SNPR2"
     if n in sumstats.columns:
-        if verbose: log.write(" -Calculating F-statistic: F = [(N-k-1)/k] * (r2/1-r2)... where k = {}".format(k))
-        if verbose: log.write(" -For r2, {} is used.".format(snpr2))
+        log.write(" -Calculating F-statistic: F = [(N-k-1)/k] * (r2/1-r2)... where k = {}".format(k), verbose=verbose)
+        log.write(" -For r2, {} is used.".format(snpr2), verbose=verbose)
         sumstats["F"] = sumstats[snpr2]*(sumstats[n]-1 -k)/((1-sumstats[snpr2]) * k)
         
-    if verbose: log.write("Finished calculating per-SNP heritibility!")
+    log.write("Finished calculating per-SNP heritability!", verbose=verbose)
     return sumstats
 #
 def get_population_allele_frequency(af, prop, odds_ratio, prevalence,eps=1e-15):

gwaslab/util_in_fill_data.py

@@ -9,7 +9,7 @@ from gwaslab.g_version import _get_version
 from gwaslab.qc_check_datatype import check_datatype
 
 def filldata( 
-    sumstats,
+    insumstats,
     to_fill=None,
     df=None,
     overwrite=False,
@@ -23,32 +23,32 @@ def filldata(
     # if a string is passed to to_fill, convert it to list
     if type(to_fill) is str:
         to_fill = [to_fill]
-
-    if verbose: log.write("Start filling data using existing columns...{}".format(_get_version()))
+    sumstats = insumstats.copy()
+    log.write("Start filling data using existing columns...{}".format(_get_version()), verbose=verbose)
     
     check_datatype(sumstats,verbose=verbose,log=log)
     
 # check dupication ##############################################################################################
     skip_cols=[]
-    if verbose: log.write(" -Overwrite mode: ",overwrite)
+    log.write(" -Overwrite mode: ",overwrite, verbose=verbose)
     if overwrite is False:
         for i in to_fill:
             if i in sumstats.columns:
                 skip_cols.append(i)
         for i in skip_cols:
             to_fill.remove(i)
-        if verbose: log.write("  -Skipping columns: ",skip_cols) 
+        log.write("  -Skipping columns: ",skip_cols, verbose=verbose) 
     if len(set(to_fill) & set(["OR","OR_95L","OR_95U","BETA","SE","P","Z","CHISQ","MLOG10P","MAF"]))==0:
         log.write(" -No available columns to fill. Skipping.", verbose=verbose)
         log.write("Finished filling data using existing columns.", verbose=verbose)
         return sumstats
-    if verbose: log.write(" -Filling columns: ",to_fill)
+    log.write(" -Filling columns: ",to_fill, verbose=verbose)
     fill_iteratively(sumstats,to_fill,log,only_sig,df,extreme,verbose,sig_level)
        
 # ###################################################################################
     #sumstats = sortcolumn(sumstats, verbose=verbose, log=log)
     gc.collect()
-    if verbose: log.write("Finished filling data using existing columns.")
+    log.write("Finished filling data using existing columns.", verbose=verbose)
     return sumstats
     
 ##########################################################################################################################    
@@ -56,20 +56,20 @@ def filldata(
 def fill_p(sumstats,log,df=None,only_sig=False,sig_level=5e-8,overwrite=False,verbose=True,filled_count=0):
         # MLOG10P -> P
     if "MLOG10P" in sumstats.columns:    
-        if verbose: log.write("  - Filling P value using MLOG10P column...")
+        log.write("  - Filling P value using MLOG10P column...", verbose=verbose)
         sumstats["P"] = np.power(10,-sumstats["MLOG10P"])
         filled_count +=1
 
     # Z -> P
     elif "Z" in sumstats.columns:
-        if verbose: log.write("  - Filling P value using Z column...")
+        log.write("  - Filling P value using Z column...", verbose=verbose)
         stats.chisqprob = lambda chisq, degree_of_freedom: stats.chi2.sf(chisq, degree_of_freedom)
         sumstats["P"] = ss.chisqprob(sumstats["Z"]**2,1)
         filled_count +=1
 
     elif "CHISQ" in sumstats.columns:
     #CHISQ -> P
-        if verbose: log.write("  - Filling P value using CHISQ column...")
+        log.write("  - Filling P value using CHISQ column...", verbose=verbose)
         stats.chisqprob = lambda chisq, degree_of_freedom: stats.chi2.sf(chisq, degree_of_freedom)
         if df is None:
             if only_sig is True and overwrite is True:
@@ -80,11 +80,11 @@ def fill_p(sumstats,log,df=None,only_sig=False,sig_level=5e-8,overwrite=False,ve
                 filled_count +=1
         else:
             if only_sig is True and overwrite is True:
-                if verbose: log.write("  - Filling P value using CHISQ column for variants:" , sum(sumstats["P"]<sig_level))
+                log.write("  - Filling P value using CHISQ column for variants:" , sum(sumstats["P"]<sig_level), verbose=verbose)
                 sumstats.loc[sumstats["P"]<sig_level,"P"] = stats.chisqprob(sumstats.loc[sumstats["P"]<sig_level,"CHISQ"],sumstats.loc[sumstats["P"]<sig_level,df].astype("int"))
                 filled_count +=1
             else:
-                if verbose: log.write("  - Filling P value using CHISQ column for all valid variants:")
+                log.write("  - Filling P value using CHISQ column for all valid variants:", verbose=verbose)
                 sumstats["P"] = stats.chisqprob(sumstats["CHISQ"],sumstats[df].astype("int"))
                 filled_count +=1
     else:
@@ -94,7 +94,7 @@ def fill_p(sumstats,log,df=None,only_sig=False,sig_level=5e-8,overwrite=False,ve
 def fill_z(sumstats,log,verbose=True,filled_count=0):
     # BETA/SE -> Z
     if ("BETA" in sumstats.columns) and ("SE" in sumstats.columns):
-        if verbose: log.write("  - Filling Z using BETA/SE column...")
+        log.write("  - Filling Z using BETA/SE column...", verbose=verbose)
         sumstats["Z"] = sumstats["BETA"]/sumstats["SE"]
         filled_count +=1
     else:
@@ -104,12 +104,12 @@ def fill_z(sumstats,log,verbose=True,filled_count=0):
 def fill_chisq(sumstats,log,verbose=True,filled_count=0):
     # Z -> CHISQ
     if "Z" in sumstats.columns:
-        if verbose: log.write("  - Filling CHISQ using Z column...")
+        log.write("  - Filling CHISQ using Z column...", verbose=verbose)
         sumstats["CHISQ"] = (sumstats["Z"])**2
         filled_count +=1
     elif "P" in sumstats.columns:
     # P -> CHISQ
-        if verbose: log.write("  - Filling CHISQ using P column...")
+        log.write("  - Filling CHISQ using P column...", verbose=verbose)
         sumstats["CHISQ"] = ss.chi2.isf(sumstats["P"], 1)
         filled_count +=1
     else:
@@ -119,13 +119,13 @@ def fill_chisq(sumstats,log,verbose=True,filled_count=0):
 def fill_or(sumstats,log,verbose=True,filled_count=0):
     # BETA -> OR
     if "BETA" in sumstats.columns:
-        if verbose: log.write("  - Filling OR using BETA column...")
+        log.write("  - Filling OR using BETA column...", verbose=verbose)
         sumstats["OR"]   = np.exp(sumstats["BETA"])
         filled_count +=1
         # BETA/SE -> OR_95L / OR_95U
         # get confidence interval 95
         if ("BETA" in sumstats.columns) and ("SE" in sumstats.columns):
-            if verbose: log.write("  - Filling OR_95L/OR_95U using BETA/SE columns...")
+            log.write("  - Filling OR_95L/OR_95U using BETA/SE columns...", verbose=verbose)
             # beta - 1.96 x se , beta + 1.96 x se
             sumstats["OR_95L"] = np.exp(sumstats["BETA"]-ss.norm.ppf(0.975)*sumstats["SE"])
             sumstats["OR_95U"] = np.exp(sumstats["BETA"]+ss.norm.ppf(0.975)*sumstats["SE"])
@@ -136,7 +136,7 @@ def fill_or(sumstats,log,verbose=True,filled_count=0):
 def fill_or95(sumstats,log,verbose=True,filled_count=0):
     # get confidence interval 95
     if ("BETA" in sumstats.columns) and ("SE" in sumstats.columns):
-        if verbose: log.write("  - Filling OR_95L/OR_95U using BETA/SE columns...")
+        log.write("  - Filling OR_95L/OR_95U using BETA/SE columns...", verbose=verbose)
         # beta - 1.96 x se , beta + 1.96 x se
         sumstats["OR_95L"] = np.exp(sumstats["BETA"]-ss.norm.ppf(0.975)*sumstats["SE"])
         sumstats["OR_95U"] = np.exp(sumstats["BETA"]+ss.norm.ppf(0.975)*sumstats["SE"])
@@ -148,7 +148,7 @@ def fill_or95(sumstats,log,verbose=True,filled_count=0):
 def fill_beta(sumstats,log,verbose=True,filled_count=0):
     # OR -> beta
     if "OR" in sumstats.columns:
-        if verbose: log.write("  - Filling BETA value using OR column...")
+        log.write("  - Filling BETA value using OR column...", verbose=verbose)
         sumstats["BETA"]  = np.log(sumstats["OR"])    
         filled_count +=1
     else:
@@ -158,27 +158,27 @@ def fill_beta(sumstats,log,verbose=True,filled_count=0):
 def fill_se(sumstats,log,verbose=True,filled_count=0):
     # OR / OR_95L /OR_95U -> SE
     if ("P" in sumstats.columns) and ("BETA" in sumstats.columns):
-        if verbose: log.write("  - Filling SE value using BETA and P column...")
+        log.write("  - Filling SE value using BETA and P column...", verbose=verbose)
         sumstats["SE"]= np.abs(sumstats["BETA"]/ ss.norm.ppf(1-sumstats["P"]/2))
         filled_count +=1
     elif ("OR" in sumstats.columns) and ("OR_95U" in sumstats.columns): 
-        if verbose: log.write("  - Filling SE value using OR/OR_95U column...")
+        log.write("  - Filling SE value using OR/OR_95U column...", verbose=verbose)
         # 
         sumstats["SE"]=(np.log(sumstats["OR_95U"]) - np.log(sumstats["OR"]))/ss.norm.ppf(0.975)
         filled_count +=1
     elif ("OR" in sumstats.columns) and ("OR_95L" in sumstats.columns):
-        if verbose: log.write("  - Filling SE value using OR/OR_95L column...")
+        log.write("  - Filling SE value using OR/OR_95L column...", verbose=verbose)
         sumstats["SE"]=(np.log(sumstats["OR"]) - np.log(sumstats["OR_95L"]))/ss.norm.ppf(0.975)
         filled_count +=1
     else:
-        if verbose: log.write("  - Not enough information to fill SE...")
+        log.write("  - Not enough information to fill SE...", verbose=verbose)
         return 0,filled_count
     return 1,filled_count
 
 def fill_mlog10p(sumstats,log,verbose=True,filled_count=0):
     if "P" in sumstats.columns:
         # P -> MLOG10P
-        if verbose: log.write("  - Filling MLOG10P using P column...")
+        log.write("  - Filling MLOG10P using P column...", verbose=verbose)
         sumstats["MLOG10P"] = -np.log10(sumstats["P"])
         filled_count +=1
     else:
@@ -188,14 +188,14 @@ def fill_extreme_mlog10p(sumstats,log,verbose=True,filled_count=0):
     # ref: https://stackoverflow.com/questions/46416027/how-to-compute-p-values-from-z-scores-in-r-when-the-z-score-is-large-pvalue-muc/46416222#46416222
     if "Z" in sumstats.columns:
         # P -> MLOG10P
-        if verbose: log.write("  - Filling MLOG10P using Z column...")
+        log.write("  - Filling MLOG10P using Z column...", verbose=verbose)
         sumstats = fill_extreme_mlog10(sumstats, "Z")
         filled_count +=1
     elif "BETA" in sumstats.columns and "SE" in sumstats.columns:
-        if verbose: log.write("  - Z column not available...")
-        if verbose: log.write("  - Filling Z using BETA/SE column...")
+        log.write("  - Z column not available...", verbose=verbose)
+        log.write("  - Filling Z using BETA/SE column...", verbose=verbose)
         sumstats["Z"] = sumstats["BETA"]/sumstats["SE"]
-        if verbose: log.write("  - Filling MLOG10P using Z column...")
+        log.write("  - Filling MLOG10P using Z column...", verbose=verbose)
         sumstats = fill_extreme_mlog10(sumstats, "Z")
         filled_count +=1
     else:
@@ -205,7 +205,7 @@ def fill_extreme_mlog10p(sumstats,log,verbose=True,filled_count=0):
 def fill_maf(sumstats,log,verbose=True,filled_count=0):
     if "EAF" in sumstats.columns:
         # EAF -> MAF
-        if verbose: log.write("  - Filling MAF using EAF column...")
+        log.write("  - Filling MAF using EAF column...", verbose=verbose)
         sumstats["MAF"] =  sumstats["EAF"].apply(lambda x: min(x,1-x) if pd.notnull(x) else np.nan)
         filled_count +=1
     else:
@@ -226,7 +226,7 @@ def fill_extreme_mlog10(sumstats, z):
 ####################################################################################################################
 def fill_iteratively(sumstats,raw_to_fill,log,only_sig,df,extreme,verbose,sig_level):
     to_fill = raw_to_fill.copy()
-    if verbose: log.write("  - Filling Columns iteratively...")
+    log.write("  - Filling Columns iteratively...", verbose=verbose)
 
     filled_count=0
     for i in range(len(to_fill)+1):