generate_plots: fix formatting and star count

generate_latex_table.py

@@ -1,9 +1,19 @@
 import pandas as pd
+import numpy as np
 from main.astrodatagui.db.StarsDB import StarDB
 
 db: StarDB = StarDB.getInstance("stars.db")
 starMainIDs = db.getAllStars()
-res = []
+resFull = []
+resUsed = []
+resUnused = []
+fullData = pd.read_pickle("datav5.1.cff")
+
+usedMstars = pd.read_csv("../large sized plots/2025-5-31-sine/M/M_starlist.csv", header=0, names=["StarName"])
+usedKstars = pd.read_csv("../large sized plots/2025-5-31-sine/K/K_starlist.csv", header=0, names=["StarName"])
+usedGstars = pd.read_csv("../large sized plots/2025-5-31-sine/G/G_starlist.csv", header=0, names=["StarName"])
+usedFstars = pd.read_csv("../large sized plots/2025-5-31-sine/F/F_starlist.csv", header=0, names=["StarName"])
+
 for mainID in starMainIDs:
     altNames = db.getStarAltNames(mainID)
     infos = db.getStarInfos(mainID)
@@ -16,16 +26,59 @@ for mainID in starMainIDs:
         if name[0].startswith("KIC"):
             kicName = name[0]
     spType = infos["SpType"]
-    res.append({"MainID": mainID,
-    "Spectral Type": spType,
-    "TIC": ticName,
-    "KIC": kicName})
     
-resDF = pd.DataFrame(res)
-resDF.sort_values(by=["Spectral Type", "MainID"]) #.to_latex(index=False)
+    hasValidSineFit = fullData[(fullData["StarName"] == mainID) & (fullData["FitType"] == "sine")]["isValidFold"].any()
+    hasValidPolyFit = fullData[(fullData["StarName"] == mainID) & (fullData["FitType"] == "poly")]["isValidFold"].any()
+    hasValidLinearFit = fullData[(fullData["StarName"] == mainID) & (fullData["FitType"] == "linear")]["isValidFold"].any()
+    
+    fitTypeString = []
+    if(hasValidSineFit): fitTypeString.append("sine")
+    if(hasValidPolyFit): fitTypeString.append("poly")
+    if(hasValidLinearFit): fitTypeString.append("linear")
+    fitTypeString = ', '.join(fitTypeString)
+
+    resFull.append({"MainID": mainID,
+                    "Spectral Type": spType,
+                    "TIC": ticName,
+                    "KIC": kicName,
+                    "Fit Types": fitTypeString})
+
+    if((usedMstars["StarName"] == mainID).any() or (usedKstars["StarName"] == mainID).any() or 
+       (usedGstars["StarName"] == mainID).any() or (usedFstars["StarName"] == mainID).any()):
+        resUsed.append({"MainID": mainID,
+                        "Spectral Type": spType,
+                        "TIC": ticName,
+                        "KIC": kicName,
+                        "Fit Types": fitTypeString})
+    else:
+        resUnused.append({"MainID": mainID,
+                          "Spectral Type": spType,
+                          "TIC": ticName,
+                          "KIC": kicName,
+                          "Fit Types": fitTypeString})
+
+
+
+resFull = pd.DataFrame(resFull)
+resFull.sort_values(by=["Spectral Type", "MainID"])
+
+resUsed = pd.DataFrame(resUsed)
+resUsed.sort_values(by=["Spectral Type", "MainID"])
+resUnused = pd.DataFrame(resUnused)
+resUnused.sort_values(by=["Spectral Type", "MainID"])
 
 for sptype in ["M", "K", "G", "F"]:
-    texFile = open(f"table_{sptype}.tex", "w")
-    tex = resDF[resDF["Spectral Type"].str.startswith(sptype)].sort_values(by=["Spectral Type", "MainID"]).to_latex(index=False)
+    texFile = open(f"table_{sptype}_used.tex", "w")
+    tex = resUsed[resUsed["Spectral Type"].str.startswith(sptype)].sort_values(by=["Spectral Type", "MainID"]).to_latex(index=False)
     texFile.write(tex)
     texFile.close()
+
+texFile = open(f"table_full.tex", "w")
+tex = resFull.sort_values(by=["Spectral Type", "MainID"]).to_latex(index=False)
+texFile.write(tex)
+texFile.close()
+
+texFile = open(f"table_unused.tex", "w")
+tex = resUnused.sort_values(by=["Spectral Type", "MainID"]).to_latex(index=False)
+texFile.write(tex)
+texFile.close()

generate_plots.py

@@ -85,7 +85,7 @@ def plotBinsHistogram(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, bins, ti
     axHisto.set_title(title, wrap=True)
     axHisto.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
     axHisto.xaxis.set_major_locator(MaxNLocator(5))
-    axHisto.legend()
+    axHisto.legend(loc="lower right")
 
     axHistoPhase = axHisto.twinx()
     if(foldedFits is None):
@@ -149,7 +149,7 @@ def plotFlarePeaks(plotdata, filters, labels, colors, maxY, title, filename):
     axFlarePeaks.set_title(title, wrap=True)
     axFlarePeaks.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
     axFlarePeaks.xaxis.set_major_locator(MaxNLocator(5))
-    axFlarePeaks.legend()
+    axFlarePeaks.legend(loc="lower right")
     plt.savefig(filename, bbox_inches="tight")
     plt.close()
 
@@ -322,6 +322,101 @@ def plotStarPeriod(data, showSourceFilter, folderPath, starName):
 
 
 def plotCombo(data, showSourceFilter, folderPath, combo):
+    # all flare peaks
+    finalDataAllFlarePeaks = pd.DataFrame()
+    if("M" in combo):
+        Mfilter = data["SpType"].str.startswith("M")
+        Mfilter &= showSourceFilter
+        finalDataAllFlarePeaks = pd.concat([finalDataAllFlarePeaks, data[Mfilter]], ignore_index=True)
+    if("K" in combo):
+        Kfilter = data["SpType"].str.startswith("K")
+        Kfilter &= showSourceFilter
+        finalDataAllFlarePeaks = pd.concat([finalDataAllFlarePeaks, data[Kfilter]], ignore_index=True)
+    if("G" in combo):
+        Gfilter = data["SpType"].str.startswith("G")
+        Gfilter &= showSourceFilter
+        finalDataAllFlarePeaks = pd.concat([finalDataAllFlarePeaks, data[Gfilter]], ignore_index=True)
+    if("F" in combo):
+        Ffilter = data["SpType"].str.startswith("F")
+        Ffilter &= showSourceFilter
+        finalDataAllFlarePeaks = pd.concat([finalDataAllFlarePeaks, data[Ffilter]], ignore_index=True)
+
+    pdcsapbinningDataAllFlarePeaks = []
+    locFolder = f"{folderPath}/{''.join(combo)}/"
+    mkdir_p(f"{locFolder}/")
+    csvFile = open(f"{locFolder}/{''.join(combo)}.csv", "a")
+    csvFile.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Normalized Phase of Peak,Peak in Period")
+    csvFile.write("\n")
+    for ind, row in finalDataAllFlarePeaks.reset_index().iterrows():
+        PDCSAPminOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][0]
+        PDCSAPmaxOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][1]
+        if(len(row["pdcsapFoldedPeaksPhasePair"]) > 0):
+                pdcsapVals = pd.DataFrame(row["pdcsapFoldedPeaksPhasePair"])
+                for td, peak, pv in zip(pdcsapVals["Phase"], pdcsapVals["Peak"], row["pdcsapPeaks"]):
+                    normPhase = normalizePhase(td.value, np.abs(PDCSAPminOrigPhase), np.abs(PDCSAPmaxOrigPhase))
+                    csvFile.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{normPhase},{peak['FlarePeak']}")
+                    csvFile.write("\n")
+                    pdcsapbinningDataAllFlarePeaks.append({"SpType": row["SpType"][0],
+                                            "PDCSAPNormPhase": normPhase,
+                                            "Peak": peak["FlarePeak"],
+                                            "StarName": row['StarName']})
+                    if(peak["FlarePeak"] > 100):
+                        print(row["StarName"], "has over 100 peak")
+
+    csvFile.close()
+    if(len(pdcsapbinningDataAllFlarePeaks) > 0):
+        pdcsapbinningDataAllFlarePeaks = pd.DataFrame(pdcsapbinningDataAllFlarePeaks)
+        numStarsAllFLarePeaks = len(set(pdcsapbinningDataAllFlarePeaks["StarName"]))
+        pd.DataFrame(set(pdcsapbinningDataAllFlarePeaks["StarName"])).to_csv(f"{locFolder}/{''.join(combo)}_starlist.csv")
+        PDCSAPdataListDataAllFlarePeaks = []
+        PDCSAPlabelListDataAllFlarePeaks = []
+        PDCSAPcolorListDataAllFlarePeaks = []
+        PDCSAPdataList2dhistPhaseDataAllFlarePeaks = []
+        PDCSAPdataList2dhistPeakDataAllFlarePeaks = []
+        PDCSAPlabelList2dhistDataAllFlarePeaks = []
+        PDCSAPcolorList2dhistDataAllFlarePeaks = []
+        plotFiltersDataAllFlarePeaks = []
+        if("M" in combo):
+            MfilterDataAllFlarePeaks = pdcsapbinningDataAllFlarePeaks["SpType"] == "M"
+            PDCSAPdataList2dhistPhaseDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[MfilterDataAllFlarePeaks]["PDCSAPNormPhase"])
+            PDCSAPdataList2dhistPeakDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[MfilterDataAllFlarePeaks]["Peak"])
+            PDCSAPdataListDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[MfilterDataAllFlarePeaks]["PDCSAPNormPhase"])
+            PDCSAPlabelListDataAllFlarePeaks.append("M Stars")
+            PDCSAPcolorListDataAllFlarePeaks.append("red")
+            plotFiltersDataAllFlarePeaks.append(MfilterDataAllFlarePeaks)
+        if("K" in combo):
+            KfilterDataAllFlarePeaks = pdcsapbinningDataAllFlarePeaks["SpType"] == "K"
+            PDCSAPdataList2dhistPhaseDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[KfilterDataAllFlarePeaks]["PDCSAPNormPhase"])
+            PDCSAPdataList2dhistPeakDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[KfilterDataAllFlarePeaks]["Peak"])
+            PDCSAPdataListDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[KfilterDataAllFlarePeaks]["PDCSAPNormPhase"])
+            PDCSAPlabelListDataAllFlarePeaks.append("K Stars")
+            PDCSAPcolorListDataAllFlarePeaks.append("orange")
+            plotFiltersDataAllFlarePeaks.append(KfilterDataAllFlarePeaks)
+        if("G" in combo):
+            GfilterDataAllFlarePeaks = pdcsapbinningDataAllFlarePeaks["SpType"] == "G"
+            PDCSAPdataList2dhistPhaseDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[GfilterDataAllFlarePeaks]["PDCSAPNormPhase"])
+            PDCSAPdataList2dhistPeakDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[GfilterDataAllFlarePeaks]["Peak"])
+            PDCSAPdataListDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[GfilterDataAllFlarePeaks]["PDCSAPNormPhase"])
+            PDCSAPlabelListDataAllFlarePeaks.append("G Stars")
+            PDCSAPcolorListDataAllFlarePeaks.append("yellow")
+            plotFiltersDataAllFlarePeaks.append(GfilterDataAllFlarePeaks)
+        if("F" in combo):
+            FfilterDataAllFlarePeaks = pdcsapbinningDataAllFlarePeaks["SpType"] == "F"
+            PDCSAPdataList2dhistPhaseDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[FfilterDataAllFlarePeaks]["PDCSAPNormPhase"])
+            PDCSAPdataList2dhistPeakDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[FfilterDataAllFlarePeaks]["Peak"])
+            PDCSAPdataListDataAllFlarePeaks.append(pdcsapbinningDataAllFlarePeaks[FfilterDataAllFlarePeaks]["PDCSAPNormPhase"])
+            PDCSAPlabelListDataAllFlarePeaks.append("F Stars")
+            PDCSAPcolorListDataAllFlarePeaks.append("greenyellow")
+            plotFiltersDataAllFlarePeaks.append(FfilterDataAllFlarePeaks)
+
+        xDataDataAllFlarePeaks, yDataDataAllFlarePeaks, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseDataAllFlarePeaks, PDCSAPdataList2dhistPeakDataAllFlarePeaks,
+                                                    pdcsapbinningDataAllFlarePeaks, "PDCSAPNormPhase")
+
+        generatePlots(PDCSAPdataListDataAllFlarePeaks, PDCSAPlabelListDataAllFlarePeaks, PDCSAPcolorListDataAllFlarePeaks, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins ({numStarsAllFLarePeaks} stars)", f"{locFolder}/{''.join(combo)}-Flarecount-@bins_Bins.png",
+                        xDataDataAllFlarePeaks, yDataDataAllFlarePeaks, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins ({numStarsAllFLarePeaks} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
+                        pdcsapbinningDataAllFlarePeaks, plotFiltersDataAllFlarePeaks, PDCSAPlabelListDataAllFlarePeaks, PDCSAPcolorListDataAllFlarePeaks, f"Flare peaks per phase of {', '.join(combo)} type stars ({numStarsAllFLarePeaks} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks_maxY-@maxY.png")
+        
+
     for maxFlarePeak in [1.01, 1.05, 1.1, 1.25, 1.5]:
         # max Flare Peak cut
         finalDataMaxFlarePeak = pd.DataFrame()
@@ -342,8 +437,6 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
             Ffilter &= showSourceFilter
             finalDataMaxFlarePeak = pd.concat([finalDataMaxFlarePeak, data[Ffilter]], ignore_index=True)
 
-        numStars = len(set(finalDataMaxFlarePeak["StarName"]))
-
         pdcsapbinningDataU = []
         pdcsapbinningDataO = []
         locFolderU = f"{folderPath}/{''.join(combo)}/maxFlarePeaks/{maxFlarePeak}/"
@@ -368,7 +461,8 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
                             csvFileU.write("\n")
                             pdcsapbinningDataU.append({"SpType": row["SpType"][0],
                                                     "PDCSAPNormPhase": normPhase,
-                                                    "Peak": peak["FlarePeak"]})
+                                                    "Peak": peak["FlarePeak"],
+                                                    "StarName": row['StarName']})
                             if(peak["FlarePeak"] > 100):
                                 print(row["StarName"], "has over 100 peak")
                         else:
@@ -377,7 +471,8 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
                             csvFileO.write("\n")
                             pdcsapbinningDataO.append({"SpType": row["SpType"][0],
                                                     "PDCSAPNormPhase": normPhase,
-                                                    "Peak": peak["FlarePeak"]})
+                                                    "Peak": peak["FlarePeak"],
+                                                    "StarName": row['StarName']})
                             if(peak["FlarePeak"] > 100):
                                 print(row["StarName"], "has over 100 peak")
 
@@ -385,6 +480,8 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
         csvFileO.close()
         if(len(pdcsapbinningDataU) > 0):
             pdcsapbinningDataU = pd.DataFrame(pdcsapbinningDataU)
+            numStarsFlarePeakU = len(set(pdcsapbinningDataU["StarName"]))
+            pd.DataFrame(set(pdcsapbinningDataU["StarName"])).to_csv(f"{locFolderU}/{''.join(combo)}_starlist.csv")
             PDCSAPdataListU = []
             PDCSAPlabelListU = []
             PDCSAPcolorListU = []
@@ -426,13 +523,14 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
 
             xData, yData, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseU, PDCSAPdataList2dhistPeakU,
                                                         pdcsapbinningDataU, "PDCSAPNormPhase")
-            generatePlots(PDCSAPdataListU, PDCSAPlabelListU, PDCSAPcolorListU, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins ({numStars} stars)", f"{locFolderU}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}-Flarecount-@bins_Bins.png",
-                            xData, yData, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins ({numStars} stars)", f"{locFolderU}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
-                            pdcsapbinningDataU, plotFiltersU, PDCSAPlabelListU, PDCSAPcolorListU, f"Flare peaks per phase of {', '.join(combo)} type stars ({numStars} stars)", f"{locFolderU}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}-Flarepeaks_maxY-@maxY.png")
-
+            generatePlots(PDCSAPdataListU, PDCSAPlabelListU, PDCSAPcolorListU, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins ({numStarsFlarePeakU} stars)", f"{locFolderU}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}-Flarecount-@bins_Bins.png",
+                            xData, yData, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins ({numStarsFlarePeakU} stars)", f"{locFolderU}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
+                            pdcsapbinningDataU, plotFiltersU, PDCSAPlabelListU, PDCSAPcolorListU, f"Flare peaks per phase of {', '.join(combo)} type stars ({numStarsFlarePeakU} stars)", f"{locFolderU}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}-Flarepeaks_maxY-@maxY.png")
 
         if(len(pdcsapbinningDataO) > 0):
             pdcsapbinningDataO = pd.DataFrame(pdcsapbinningDataO)
+            numStarsFlarePeakO = len(set(pdcsapbinningDataO["StarName"]))
+            pd.DataFrame(set(pdcsapbinningDataO["StarName"])).to_csv(f"{locFolderO}/{''.join(combo)}_starlist.csv")
             PDCSAPdataListO = []
             PDCSAPlabelListO = []
             PDCSAPcolorListO = []
@@ -474,102 +572,9 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
 
             xData, yData, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseO, PDCSAPdataList2dhistPeakO,
                                                         pdcsapbinningDataO, "PDCSAPNormPhase")
-            generatePlots(PDCSAPdataListO, PDCSAPlabelListO, PDCSAPcolorListO, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins ({numStars} stars)", f"{locFolderO}/{''.join(combo)}_minFlarePeak_{maxFlarePeak}-Flarecount-@bins_Bins.png",
-                            xData, yData, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins ({numStars} stars)", f"{locFolderO}/{''.join(combo)}_minFlarePeak_{maxFlarePeak}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
-                            pdcsapbinningDataO, plotFiltersO, PDCSAPlabelListO, PDCSAPcolorListO, f"Flare peaks per phase of {', '.join(combo)} type stars ({numStars} stars)", f"{locFolderO}/{''.join(combo)}_minFlarePeak_{maxFlarePeak}-Flarepeaks_maxY-@maxY.png")
-    # all flare peaks
-    finalDataAllFlarePeaks = pd.DataFrame()
-    if("M" in combo):
-        Mfilter = data["SpType"].str.startswith("M")
-        Mfilter &= showSourceFilter
-        finalDataAllFlarePeaks = pd.concat([finalDataAllFlarePeaks, data[Mfilter]], ignore_index=True)
-    if("K" in combo):
-        Kfilter = data["SpType"].str.startswith("K")
-        Kfilter &= showSourceFilter
-        finalDataAllFlarePeaks = pd.concat([finalDataAllFlarePeaks, data[Kfilter]], ignore_index=True)
-    if("G" in combo):
-        Gfilter = data["SpType"].str.startswith("G")
-        Gfilter &= showSourceFilter
-        finalDataAllFlarePeaks = pd.concat([finalDataAllFlarePeaks, data[Gfilter]], ignore_index=True)
-    if("F" in combo):
-        Ffilter = data["SpType"].str.startswith("F")
-        Ffilter &= showSourceFilter
-        finalDataAllFlarePeaks = pd.concat([finalDataAllFlarePeaks, data[Ffilter]], ignore_index=True)
-
-    numStars = len(set(finalDataAllFlarePeaks["StarName"]))
-
-    pdcsapbinningData = []
-    locFolder = f"{folderPath}/{''.join(combo)}/"
-    mkdir_p(f"{locFolder}/")
-    csvFile = open(f"{locFolder}/{''.join(combo)}.csv", "a")
-    csvFile.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Normalized Phase of Peak,Peak in Period")
-    csvFile.write("\n")
-    for ind, row in finalDataAllFlarePeaks.reset_index().iterrows():
-        PDCSAPminOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][0]
-        PDCSAPmaxOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][1]
-        if(len(row["pdcsapFoldedPeaksPhasePair"]) > 0):
-                pdcsapVals = pd.DataFrame(row["pdcsapFoldedPeaksPhasePair"])
-                for td, peak, pv in zip(pdcsapVals["Phase"], pdcsapVals["Peak"], row["pdcsapPeaks"]):
-                    normPhase = normalizePhase(td.value, np.abs(PDCSAPminOrigPhase), np.abs(PDCSAPmaxOrigPhase))
-                    csvFile.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{normPhase},{peak['FlarePeak']}")
-                    csvFile.write("\n")
-                    pdcsapbinningData.append({"SpType": row["SpType"][0],
-                                            "PDCSAPNormPhase": normPhase,
-                                            "Peak": peak["FlarePeak"]})
-                    if(peak["FlarePeak"] > 100):
-                        print(row["StarName"], "has over 100 peak")
-
-    csvFile.close()
-    if(len(pdcsapbinningData) > 0):
-        pdcsapbinningData = pd.DataFrame(pdcsapbinningData)
-        PDCSAPdataList = []
-        PDCSAPlabelList = []
-        PDCSAPcolorList = []
-        PDCSAPdataList2dhistPhase = []
-        PDCSAPdataList2dhistPeak = []
-        PDCSAPlabelList2dhist = []
-        PDCSAPcolorList2dhist = []
-        plotFilters = []
-        if("M" in combo):
-            Mfilter = pdcsapbinningData["SpType"] == "M"
-            PDCSAPdataList2dhistPhase.append(pdcsapbinningData[Mfilter]["PDCSAPNormPhase"])
-            PDCSAPdataList2dhistPeak.append(pdcsapbinningData[Mfilter]["Peak"])
-            PDCSAPdataList.append(pdcsapbinningData[Mfilter]["PDCSAPNormPhase"])
-            PDCSAPlabelList.append("M Stars")
-            PDCSAPcolorList.append("red")
-            plotFilters.append(Mfilter)
-        if("K" in combo):
-            Kfilter = pdcsapbinningData["SpType"] == "K"
-            PDCSAPdataList2dhistPhase.append(pdcsapbinningData[Kfilter]["PDCSAPNormPhase"])
-            PDCSAPdataList2dhistPeak.append(pdcsapbinningData[Kfilter]["Peak"])
-            PDCSAPdataList.append(pdcsapbinningData[Kfilter]["PDCSAPNormPhase"])
-            PDCSAPlabelList.append("K Stars")
-            PDCSAPcolorList.append("orange")
-            plotFilters.append(Kfilter)
-        if("G" in combo):
-            Gfilter = pdcsapbinningData["SpType"] == "G"
-            PDCSAPdataList2dhistPhase.append(pdcsapbinningData[Gfilter]["PDCSAPNormPhase"])
-            PDCSAPdataList2dhistPeak.append(pdcsapbinningData[Gfilter]["Peak"])
-            PDCSAPdataList.append(pdcsapbinningData[Gfilter]["PDCSAPNormPhase"])
-            PDCSAPlabelList.append("G Stars")
-            PDCSAPcolorList.append("yellow")
-            plotFilters.append(Gfilter)
-        if("F" in combo):
-            Ffilter = pdcsapbinningData["SpType"] == "F"
-            PDCSAPdataList2dhistPhase.append(pdcsapbinningData[Ffilter]["PDCSAPNormPhase"])
-            PDCSAPdataList2dhistPeak.append(pdcsapbinningData[Ffilter]["Peak"])
-            PDCSAPdataList.append(pdcsapbinningData[Ffilter]["PDCSAPNormPhase"])
-            PDCSAPlabelList.append("F Stars")
-            PDCSAPcolorList.append("greenyellow")
-            plotFilters.append(Ffilter)
-
-        xData, yData, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak,
-                                                    pdcsapbinningData, "PDCSAPNormPhase",)
-        plotdata = pdcsapbinningData
-        filters = plotFilters
-        generatePlots(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins ({numStars} stars)", f"{locFolder}/{''.join(combo)}-Flarecount-@bins_Bins.png",
-                        xData, yData, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins ({numStars} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
-                        plotdata, filters, PDCSAPlabelList, PDCSAPcolorList, f"Flare peaks per phase of {', '.join(combo)} type stars ({numStars} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks_maxY-@maxY.png")
+            generatePlots(PDCSAPdataListO, PDCSAPlabelListO, PDCSAPcolorListO, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins ({numStarsFlarePeakO} stars)", f"{locFolderO}/{''.join(combo)}_minFlarePeak_{maxFlarePeak}-Flarecount-@bins_Bins.png",
+                            xData, yData, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins ({numStarsFlarePeakO} stars)", f"{locFolderO}/{''.join(combo)}_minFlarePeak_{maxFlarePeak}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
+                            pdcsapbinningDataO, plotFiltersO, PDCSAPlabelListO, PDCSAPcolorListO, f"Flare peaks per phase of {', '.join(combo)} type stars ({numStarsFlarePeakO} stars)", f"{locFolderO}/{''.join(combo)}_minFlarePeak_{maxFlarePeak}-Flarepeaks_maxY-@maxY.png")
     
     if(len(combo) == 1):
         mainSpType = combo[0]
@@ -588,7 +593,6 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
             finalDataAccSpTypes = pd.DataFrame()
         
             typeFilter = data["SpType"].str.startswith(spTyp)
-            numStars = len(set(data[typeFilter]["StarName"]))
             typeFilter &= showSourceFilter
             finalDataAccSpTypes = pd.concat([finalDataAccSpTypes, data[typeFilter]], ignore_index=True)
 
@@ -609,12 +613,15 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
                             csvFile.write("\n")
                             pdcsapbinningData.append({"SpType": f'{row["SpType"][0]}{row["SpType"][1]}',
                                                     "PDCSAPNormPhase": normPhase,
-                                                    "Peak": peak["FlarePeak"]})
+                                                    "Peak": peak["FlarePeak"],
+                                                    "StarName": row['StarName']})
                             if(peak["FlarePeak"] > 100):
                                 print(row["StarName"], "has over 100 peak")
             csvFile.close()
             if(len(pdcsapbinningData) > 0):
                 pdcsapbinningData = pd.DataFrame(pdcsapbinningData)
+                numStarsAccSpType = len(set(pdcsapbinningData["StarName"]))
+                pd.DataFrame(set(pdcsapbinningData["StarName"])).to_csv(f"{locFolder}/{spTyp}_starlist.csv")
                 PDCSAPdataList = []
                 PDCSAPlabelList = []
                 PDCSAPcolorList = []
@@ -637,9 +644,9 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
 
                 plotdata = pdcsapbinningData
                 filters = SpTypefilter
-                generatePlots(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, f"Flare count in phase of {spTyp} type stars with @bins bins ({numStars} stars)", f"{locFolder}/{''.join(spTyp)}-Flarecount-@bins_Bins.png",
-                                xData, yData, f"Flare peak per phase histogram of {spTyp} type stars with @bins bins ({numStars} stars)", f"{locFolder}/{''.join(spTyp)}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
-                                plotdata, filters, PDCSAPlabelList[0], PDCSAPcolorList[0], f"Flare peaks per phase of {spTyp} type stars ({numStars} stars)", f"{locFolder}/{''.join(spTyp)}-Flarepeaks_maxY-@maxY.png")
+                generatePlots(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, f"Flare count in phase of {spTyp} type stars with @bins bins ({numStarsAccSpType} stars)", f"{locFolder}/{''.join(spTyp)}-Flarecount-@bins_Bins.png",
+                                xData, yData, f"Flare peak per phase histogram of {spTyp} type stars with @bins bins ({numStarsAccSpType} stars)", f"{locFolder}/{''.join(spTyp)}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
+                                plotdata, filters, PDCSAPlabelList[0], PDCSAPcolorList[0], f"Flare peaks per phase of {spTyp} type stars ({numStarsAccSpType} stars)", f"{locFolder}/{''.join(spTyp)}-Flarepeaks_maxY-@maxY.png")
         
     # per Period
     for periodCut in periodsCutList:
@@ -687,13 +694,15 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
                             csvFileU.write("\n")
                             pdcsapbinningDataU.append({"SpType": f'{row["SpType"][0]}',
                                                         "PDCSAPNormPhase": normPhase,
-                                                        "Peak": peak["FlarePeak"]})
+                                                        "Peak": peak["FlarePeak"],
+                                                        "StarName": row['StarName']})
                         else:
                             csvFileO.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{row['MeanPeriod']},{normPhase},{peak['FlarePeak']}")
                             csvFileO.write("\n")
                             pdcsapbinningDataO.append({"SpType": f'{row["SpType"][0]}',
                                                         "PDCSAPNormPhase": normPhase,
-                                                        "Peak": peak["FlarePeak"]})
+                                                        "Peak": peak["FlarePeak"],
+                                                        "StarName": row['StarName']})
                         if(peak["FlarePeak"] > 100):
                             print(row["StarName"], "has over 100 peak")
         csvFileU.close()
@@ -721,6 +730,8 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
             PDCSAPcolorList.append("greenyellow")
 
         if(len(pdcsapbinningDataU) > 0):
+            numStarsPeriodU = len(set(pdcsapbinningDataU["StarName"]))
+            pd.DataFrame(set(pdcsapbinningDataU["StarName"])).to_csv(f"{locFolder}/under_{periodCut}_starlist.csv")
             if("M" in combo):
                 MfilterU = pdcsapbinningDataU["SpType"] == "M"
                 PDCSAPdataList2dhistPhaseU.append(pdcsapbinningDataU[MfilterU]["PDCSAPNormPhase"])
@@ -747,6 +758,8 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
                 plotFiltersU.append(FfilterU)
 
         if(len(pdcsapbinningDataO) > 0):
+            numStarsPeriodO = len(set(pdcsapbinningDataO["StarName"]))
+            pd.DataFrame(set(pdcsapbinningDataO["StarName"])).to_csv(f"{locFolder}/over_{periodCut}_starlist.csv")
             if("M" in combo):
                 MfilterO = pdcsapbinningDataO["SpType"] == "M"
                 PDCSAPdataList2dhistPhaseO.append(pdcsapbinningDataO[MfilterO]["PDCSAPNormPhase"])
@@ -776,17 +789,17 @@ def plotCombo(data, showSourceFilter, folderPath, combo):
             xDataU, yDataU, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseU, PDCSAPdataList2dhistPeakU,
                                                         pdcsapbinningDataU, "PDCSAPNormPhase",)
             if(len(PDCSAPdataListU) > 0 and len(xDataU) > 0 and len(yDataU) > 0):
-                generatePlots(PDCSAPdataListU, PDCSAPlabelList, PDCSAPcolorList, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins (Rot. Period under {periodCut} days)", f"{locFolder}/{''.join(combo)}-Flarecount-Period_u_{periodCut}-@bins_Bins.png",
-                                xDataU, yDataU, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins (Rot. Period under {periodCut} days)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_u_{periodCut}-@bins_Bins_maxY-@maxY.png",
-                                pdcsapbinningDataU, plotFiltersU, PDCSAPlabelList, PDCSAPcolorList, f"Flare peaks per phase of {', '.join(combo)} type stars (Rot. Period under {periodCut} days)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_u_{periodCut}-maxY_@maxY.png")
+                generatePlots(PDCSAPdataListU, PDCSAPlabelList, PDCSAPcolorList, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins (Rot. Period under {periodCut} days, {numStarsPeriodU} stars)", f"{locFolder}/{''.join(combo)}-Flarecount-Period_u_{periodCut}-@bins_Bins.png",
+                                xDataU, yDataU, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins (Rot. Period under {periodCut} days, {numStarsPeriodU} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_u_{periodCut}-@bins_Bins_maxY-@maxY.png",
+                                pdcsapbinningDataU, plotFiltersU, PDCSAPlabelList, PDCSAPcolorList, f"Flare peaks per phase of {', '.join(combo)} type stars (Rot. Period under {periodCut} days, {numStarsPeriodU} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_u_{periodCut}-maxY_@maxY.png")
 
         if(len(PDCSAPdataList2dhistPhaseO) > 0 and len(PDCSAPdataList2dhistPeakO) > 0):
             xDataO, yDataO, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseO, PDCSAPdataList2dhistPeakO,
                                                         pdcsapbinningDataO, "PDCSAPNormPhase",)
             if(len(PDCSAPdataListO) > 0 and len(xDataO) > 0 and len(yDataO) > 0):
-                generatePlots(PDCSAPdataListO, PDCSAPlabelList, PDCSAPcolorList, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins (Rot. Period over {periodCut} days)", f"{locFolder}/{''.join(combo)}-Flarecount-Period_o_{periodCut}-@bins_Bins.png",
-                                xDataO, yDataO, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins (Rot. Period over {periodCut} days)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_o_{periodCut}-@bins_Bins_maxY-@maxY.png",
-                                pdcsapbinningDataO, plotFiltersO, PDCSAPlabelList, PDCSAPcolorList, f"Flare peaks per phase of {', '.join(combo)} type stars (Rot. Period over {periodCut} days)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_o_{periodCut}-maxY_@maxY.png")
+                generatePlots(PDCSAPdataListO, PDCSAPlabelList, PDCSAPcolorList, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins (Rot. Period over {periodCut} days, {numStarsPeriodO} stars)", f"{locFolder}/{''.join(combo)}-Flarecount-Period_o_{periodCut}-@bins_Bins.png",
+                                xDataO, yDataO, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins (Rot. Period over {periodCut} days, {numStarsPeriodO} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_o_{periodCut}-@bins_Bins_maxY-@maxY.png",
+                                pdcsapbinningDataO, plotFiltersO, PDCSAPlabelList, PDCSAPcolorList, f"Flare peaks per phase of {', '.join(combo)} type stars (Rot. Period over {periodCut} days, {numStarsPeriodO} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_o_{periodCut}-maxY_@maxY.png")
 
 binList = [10, 20, 30]
 spType = ["M", "K", "G", "F"]
@@ -851,11 +864,11 @@ if __name__ == "__main__":
 
             data = pd.merge(data, validStarPeriodMap, on="StarName")
             
-            starPlotFunc = partial(plotStar, data, showSourceFilter, folderPath)
-            list(pool.map(starPlotFunc, allStars)) # wrap in list, to force evaluation
+            #starPlotFunc = partial(plotStar, data, showSourceFilter, folderPath)
+            #list(pool.map(starPlotFunc, allStars)) # wrap in list, to force evaluation
             
-            starPlotPeriodFunc = partial(plotStarPeriod, dataPeriod, showSourceFilter, folderPath)
-            list(pool.map(starPlotPeriodFunc, allStars)) # wrap in list, to force evaluation
+            #starPlotPeriodFunc = partial(plotStarPeriod, dataPeriod, showSourceFilter, folderPath)
+            #list(pool.map(starPlotPeriodFunc, allStars)) # wrap in list, to force evaluation
 
             combos = []
             for comboLength in range(1, len(spType) + 1):

main/astrodatagui/CalcAllFlaresThread.py

@@ -15,6 +15,18 @@ from errno import EEXIST
 from os import makedirs, path
 from datetime import datetime
 
+SMALL_SIZE = 16
+MEDIUM_SIZE = 18
+BIGGER_SIZE = 20
+
+plt.rc('font', size=SMALL_SIZE)          # controls default text sizes
+plt.rc('axes', titlesize=MEDIUM_SIZE)     # fontsize of the axes title
+plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels
+plt.rc('xtick', labelsize=SMALL_SIZE)    # fontsize of the tick labels
+plt.rc('ytick', labelsize=SMALL_SIZE)    # fontsize of the tick labels
+plt.rc('legend', fontsize=SMALL_SIZE)    # legend fontsize
+plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title
+
 def mkdir_p(mypath):
     '''Creates a directory. equivalent to using mkdir -p on the command line'''
 
@@ -48,13 +60,13 @@ def getFlareCount(filesDict):
 
         lc.plot()
         plt.title(f"{starName} - normalized lightcurve")
-        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-lc.png")
+        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-lc.png", bbox_inches="tight")
         plt.close()
 
         flattenedLc = lc.flatten()
         flattenedLc.plot()
         plt.title(f"{starName} - flattened lightcurve")
-        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-flattened_lc.png")
+        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-flattened_lc.png", bbox_inches="tight")
         plt.close()
 
         pdcsapPeaks, pdcsapFits = calculateFlareFitsForLightcurve(flattenedLc, normalizedLC=lc)
@@ -64,7 +76,7 @@ def getFlareCount(filesDict):
             plt.plot(p["FlarePeakTime"].value, lc.flux[p["StandardIndex"]], "x", color="red")
         plt.plot([], [], "x", color="red", label="Flare peaks")
         plt.legend()
-        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-lc-marked_flares.png")
+        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-lc-marked_flares.png", bbox_inches="tight")
         plt.close()
 
         flattenedLc.plot()
@@ -76,7 +88,7 @@ def getFlareCount(filesDict):
             plt.plot(p["FlarePeakTime"].value, p["FlarePeak"], "x", color="red")
         plt.plot([], [], "x", color="red", label="Flare peaks")
         plt.legend()
-        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-flattened_lc-marked_flares.png")
+        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-flattened_lc-marked_flares.png", bbox_inches="tight")
         plt.close()
 
         pdcsapValSec, pdcsapTds = getTotalValidDataInSeconds(lc, "pdcsap_flux")
@@ -86,7 +98,7 @@ def getFlareCount(filesDict):
 
         pdcsapPeriodogram.plot(view="period")
         plt.plot(pdcsapPeakPeriod, pdcsapPeriodogram.power[maxPeriodIndex], "x", color="red")
-        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-periodogram-marked_max.png")
+        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-periodogram-marked_max.png", bbox_inches="tight")
         plt.close()
 
         #pdcsapEpochTime = getEpochTime(lc)
@@ -108,7 +120,7 @@ def getFlareCount(filesDict):
                      optimizedFit["foldedLC"].flux[optimizedFit["foldedLC"].cycle == cycle][foldedIndex], "x", color="red")
         plt.plot([], [], "x", color="red", label="Flare peaks")
         plt.legend()
-        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-foldedLC-marked_fit_flares.png")
+        plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-foldedLC-marked_fit_flares.png", bbox_inches="tight")
         plt.close()
 
         if(optimizedFit["periodFoldedLC"] is not None):
@@ -123,7 +135,7 @@ def getFlareCount(filesDict):
                          optimizedFit["periodFoldedLC"].flux[optimizedFit["periodFoldedLC"].cycle == cycle][foldedIndex], "x", color="red")
             plt.plot([], [], "x", color="red", label="Flare peaks")
             plt.legend()
-            plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-periodFoldedLC-marked_fit_flares.png")
+            plt.savefig(f"{starFolder}/{starNameR}_{source}-{sequence}-periodFoldedLC-marked_fit_flares.png", bbox_inches="tight")
             plt.close()
         
         filesDict["pdcsapPeaks"] = pdcsapPeaks

main/astrodatagui/FlareSummaryPlotGUI.py

@@ -120,7 +120,7 @@ class FlareSummaryPlotGUI(QWidget):
         self.cbSpTypeUnknown.setChecked(False)
 
         self.cbShowSAP = QCheckBox("SAP")
-        self.cbShowSAP.setChecked(True)
+        self.cbShowSAP.setChecked(False)
         self.cbShowPDCSAP = QCheckBox("PDCSAP")
         self.cbShowPDCSAP.setChecked(True)
 
@@ -129,12 +129,12 @@ class FlareSummaryPlotGUI(QWidget):
         self.buttonGridLayout.addWidget(self.btShowFlaresPerStar, 0, 2)
         self.buttonGridLayout.addWidget(self.btShowFlaresPerStarNormalized, 0, 3)
         self.buttonGridLayout.addWidget(self.btShowPeriods, 0, 4)
-        self.buttonGridLayout.addWidget(self.btNumMinimaMaxima, 0, 5)
-        self.buttonGridLayout.addWidget(self.btNumMinimaMaximaNorm, 0, 6)
-        self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaxima, 0, 7)
-        self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaximaPerMinimaMaxima, 0, 8)
-        self.buttonGridLayout.addWidget(self.btShowFlaresBinnedOnPhase, 0, 9)
-        self.buttonGridLayout.addWidget(self.textNumBins, 0, 10)
+        #self.buttonGridLayout.addWidget(self.btNumMinimaMaxima, 0, 5)
+        #self.buttonGridLayout.addWidget(self.btNumMinimaMaximaNorm, 0, 6)
+        #self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaxima, 0, 7)
+        #self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaximaPerMinimaMaxima, 0, 8)
+        #self.buttonGridLayout.addWidget(self.btShowFlaresBinnedOnPhase, 0, 9)
+        #self.buttonGridLayout.addWidget(self.textNumBins, 0, 10)
 
         self.buttonGridLayout.addWidget(QLabel("Sources: "), 1, 0)
         self.buttonGridLayout.addWidget(self.cbKepler, 1, 1)
@@ -149,7 +149,7 @@ class FlareSummaryPlotGUI(QWidget):
         self.buttonGridLayout.addWidget(self.cbSpTypeF, 2, 4)
         #self.buttonGridLayout.addWidget(self.cbSpTypeUnknown, 2, 6)
         
-        self.buttonGridLayout.addWidget(self.cbShowSAP, 3, 0)
+        #self.buttonGridLayout.addWidget(self.cbShowSAP, 3, 0)
         self.buttonGridLayout.addWidget(self.cbShowPDCSAP, 3, 1)
 
         self.mainLayout.addLayout(self.buttonGridLayout)
@@ -243,27 +243,7 @@ class FlareSummaryPlotGUI(QWidget):
         self.figure.canvas.draw_idle()
 
     def btShowFlaresPerStarClicked(self):
-        data = self.starFLareDictList.drop(columns=['Distance',
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'pdcsapPeaks',
-                                                    'sapFits',
-                                                    'sapPeaks',
-                                                    'sapPeriod',
-                                                    'sapPeriodMinima',
-                                                    'sapPeriodMinimaBoundaries',
-                                                    'sapPeriodMaxima',
-                                                    'sapPeriodMaximaBoundaries',
-                                                    'pdcsapValidTimespans',
-                                                    'pdcsapPeriod',
-                                                    'pdcsapPeriodMinima',
-                                                    'pdcsapPeriodMinimaBoundaries',
-                                                    'pdcsapPeriodMaxima',
-                                                    'pdcsapPeriodMaximaBoundaries'])
+        data = self.starFLareDictList
 
         showSourceFilter = np.full(len(data), False)
 
@@ -277,9 +257,14 @@ class FlareSummaryPlotGUI(QWidget):
             showTESS = data["Source"] == "TESS"
             showSourceFilter |= showTESS
 
+        aggDic = {}
+        if(self.cbShowSAP.isChecked()):
+            aggDic["sapPeaksCount"] = "sum"
+        if(self.cbShowPDCSAP.isChecked()):
+            aggDic["pdcsapPeaksCount"] = "sum"
+
         data = data[showSourceFilter].groupby(["StarName", "SpType"],
-                            as_index=False).agg({"sapPeaksCount": "sum",
-                                                 "pdcsapPeaksCount": "sum"})
+                            as_index=False).agg(aggDic)
         x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int)
 
         if(self.cbSpTypeL.isChecked()):
@@ -345,28 +330,7 @@ class FlareSummaryPlotGUI(QWidget):
         self.figure.canvas.draw_idle()
 
     def btShowFlaresPerStarNormalizedClicked(self):
-        data = self.starFLareDictList.drop(columns=['Distance',
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'pdcsapPeaks',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'sapPeaks',
-                                                    'sapPeriod',
-                                                    'sapPeriodMinima',
-                                                    'sapPeriodMinimaBoundaries',
-                                                    'sapPeriodMaxima',
-                                                    'sapPeriodMaximaBoundaries',
-                                                    'pdcsapValidTimespans',
-                                                    'pdcsapPeriod',
-                                                    'pdcsapPeriodMinima',
-                                                    'pdcsapPeriodMinimaBoundaries',
-                                                    'pdcsapPeriodMaxima',
-                                                    'pdcsapPeriodMaximaBoundaries'])
+        data = self.starFLareDictList
 
         showSourceFilter = np.full(len(data), False)
 
@@ -380,11 +344,16 @@ class FlareSummaryPlotGUI(QWidget):
             showTESS = data["Source"] == "TESS"
             showSourceFilter |= showTESS
 
+        aggDic = {}
+        if(self.cbShowSAP.isChecked()):
+            aggDic["sapPeaksCount"] = "sum"
+            aggDic["sapValidSeconds"] = "sum"
+        if(self.cbShowPDCSAP.isChecked()):
+            aggDic["pdcsapPeaksCount"] = "sum"
+            aggDic["pdcsapValidSeconds"] = "sum"
+
         data = data[showSourceFilter].groupby(["StarName", "SpType"],
-                            as_index=False).agg({"sapPeaksCount": "sum",
-                                                 "pdcsapPeaksCount": "sum",
-                                                 "sapValidSeconds": "sum",
-                                                 "pdcsapValidSeconds": "sum"})
+                            as_index=False).agg(aggDic)
         x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int)
 
         if(self.cbSpTypeL.isChecked()):
@@ -462,30 +431,7 @@ class FlareSummaryPlotGUI(QWidget):
         self.figure.canvas.draw_idle()
 
     def btShowPeriodsClicked(self):
-        data = self.starFLareDictList.drop(columns=['Distance',
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'pdcsapPeaks',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'sapPeaks',
-                                                    'sapPeriodMinima',
-                                                    'sapPeriodMinimaBoundaries',
-                                                    'sapPeriodMaxima',
-                                                    'sapPeriodMaximaBoundaries',
-                                                    'pdcsapValidTimespans',
-                                                    'pdcsapPeriodMinima',
-                                                    'pdcsapPeriodMinimaBoundaries',
-                                                    'pdcsapPeriodMaxima',
-                                                    'pdcsapPeriodMaximaBoundaries',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
+        data = self.starFLareDictList
 
         showSourceFilter = np.full(len(data), False)
 
@@ -499,11 +445,14 @@ class FlareSummaryPlotGUI(QWidget):
             showTESS = data["Source"] == "TESS"
             showSourceFilter |= showTESS
 
-        print(data["sapPeriod"])
+        aggDic = {}
+        if(self.cbShowSAP.isChecked()):
+            aggDic["sapPeriod"] = "sum"
+        if(self.cbShowPDCSAP.isChecked()):
+            aggDic["pdcsapPeriod"] = "sum"
 
         data = data[showSourceFilter].groupby(["StarName", "SpType"],
-                            as_index=False).agg({"sapPeriod": "mean",
-                                                 "pdcsapPeriod": "mean"})
+                            as_index=False).agg(aggDic)
         x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int)
 
         if(self.cbSpTypeL.isChecked()):
@@ -582,20 +531,7 @@ class FlareSummaryPlotGUI(QWidget):
         pass
 
     def btShowNumMinimaMaximaClicked(self):
-        data = self.starFLareDictList.drop(columns=['Distance',
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'pdcsapValidTimespans',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
+        data = self.starFLareDictList
 
         showSourceFilter = np.full(len(data), False)
 
@@ -609,13 +545,15 @@ class FlareSummaryPlotGUI(QWidget):
             showTESS = data["Source"] == "TESS"
             showSourceFilter |= showTESS
 
-        print(data["sapPeriod"])
-
+        aggDic = {}
+        if(self.cbShowSAP.isChecked()):
+            aggDic["sapPeriodMinima"] = "sum"
+            aggDic["sapPeriodMaxima"] = "sum"
+        if(self.cbShowPDCSAP.isChecked()):
+            aggDic["pdcsapPeriodMinima"] = "sum"
+            aggDic["pdcsapPeriodMaxima"] = "sum"
         data = data[showSourceFilter].groupby(["StarName", "SpType"],
-                            as_index=False).agg({"sapPeriodMinima": sumArrayLengths,
-                                                 "sapPeriodMaxima": sumArrayLengths,
-                                                 "pdcsapPeriodMinima": sumArrayLengths,
-                                                 "pdcsapPeriodMaxima": sumArrayLengths})
+                            as_index=False).agg(aggDic)
         x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int)
 
         if(self.cbSpTypeL.isChecked()):
@@ -718,20 +656,7 @@ class FlareSummaryPlotGUI(QWidget):
         pass
 
     def btShowNumMinimaMaximaNormalizedClicked(self):
-        data = self.starFLareDictList.drop(columns=['Distance',
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'pdcsapValidTimespans',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
+        data = self.starFLareDictList
 
         showSourceFilter = np.full(len(data), False)
 
@@ -745,13 +670,15 @@ class FlareSummaryPlotGUI(QWidget):
             showTESS = data["Source"] == "TESS"
             showSourceFilter |= showTESS
 
-        print(data["sapPeriod"])
-
+        aggDic = {}
+        if(self.cbShowSAP.isChecked()):
+            aggDic["sapPeriodMinima"] = "sum"
+            aggDic["sapPeriodMaxima"] = "sum"
+        if(self.cbShowPDCSAP.isChecked()):
+            aggDic["pdcsapPeriodMinima"] = "sum"
+            aggDic["pdcsapPeriodMaxima"] = "sum"
         data = data[showSourceFilter].groupby(["StarName", "SpType"],
-                            as_index=False).agg({"sapPeriodMinima": sumArrayLengthsNorm,
-                                                 "sapPeriodMaxima": sumArrayLengthsNorm,
-                                                 "pdcsapPeriodMinima": sumArrayLengthsNorm,
-                                                 "pdcsapPeriodMaxima": sumArrayLengthsNorm})
+                            as_index=False).agg(aggDic)
         x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int)
 
         if(self.cbSpTypeL.isChecked()):
@@ -854,20 +781,7 @@ class FlareSummaryPlotGUI(QWidget):
         pass
 
     def btShowFlaresInMinimaMaximaClicked(self):
-        data = self.starFLareDictList.drop(columns=['Distance',
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'pdcsapValidTimespans',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
+        data = self.starFLareDictList
 
         showSourceFilter = np.full(len(data), False)
 
@@ -881,8 +795,6 @@ class FlareSummaryPlotGUI(QWidget):
             showTESS = data["Source"] == "TESS"
             showSourceFilter |= showTESS
 
-        print(data["sapPeriod"])
-
         finalData = []
         #data = data[showSourceFilter].groupby(["StarName", "SpType"],
         #                    as_index=False).agg({"sapPeriod": "mean",
@@ -1011,20 +923,7 @@ class FlareSummaryPlotGUI(QWidget):
         pass
 
     def btShowFlaresInMinimaMaximaPerMinimaMaximaClicked(self):
-        data = self.starFLareDictList.drop(columns=['Distance',
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'pdcsapValidTimespans',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
+        data = self.starFLareDictList
 
         showSourceFilter = np.full(len(data), False)
 
@@ -1038,8 +937,6 @@ class FlareSummaryPlotGUI(QWidget):
             showTESS = data["Source"] == "TESS"
             showSourceFilter |= showTESS
 
-        print(data["sapPeriod"])
-
         finalData = []
         for ind, row in data[showSourceFilter].reset_index().iterrows():
             minimaCountSAP = getNumFlaresInBounds(row["sapFoldedPeaksPhasePair"], 
@@ -1056,15 +953,20 @@ class FlareSummaryPlotGUI(QWidget):
                               "minimaCountPDCSAP": minimaCountPDCSAP, "maximaCountPDCSAP": maximaCountPDCSAP,
                               "minimasPDCSAP": len(row["pdcsapPeriodMinima"]), "maximasPDCSAP": len(row["pdcsapPeriodMaxima"])})
             
+        aggDic = {}
+        if(self.cbShowSAP.isChecked()):
+            aggDic["minimaCountSAP"] = "sum"
+            aggDic["maximaCountSAP"] = "sum"
+            aggDic["minimasSAP"] = "sum"
+            aggDic["maximasSAP"] = "sum"
+        if(self.cbShowPDCSAP.isChecked()):
+            aggDic["minimaCountPDCSAP"] = "sum"
+            aggDic["maximaCountPDCSAP"] = "sum"
+            aggDic["minimasPDCSAP"] = "sum"
+            aggDic["maximasPDCSAP"] = "sum"
+
         data = pd.DataFrame(finalData).groupby(["StarName", "SpType"],
-                            as_index=False).agg({"minimaCountSAP": "sum",
-                                                 "maximaCountSAP": "sum",
-                                                 "minimasSAP": "sum",
-                                                 "maximasSAP": "sum",
-                                                 "minimaCountPDCSAP": "sum",
-                                                 "maximaCountPDCSAP": "sum",
-                                                 "minimasPDCSAP": "sum",
-                                                 "maximasPDCSAP": "sum"})
+                            as_index=False).agg(aggDic)
         x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int)
 
         if(self.cbSpTypeL.isChecked()):

main/astrodatagui/ui/FlaredetectorWidget.py

@@ -301,8 +301,8 @@ class FlaredetectorWidget(QtWidgets.QWidget):
                     phase, sineFit, _ = getFoldedBestFit(lc, fitType=self.foldedFitType)
                     self.figureAxis.plot(phase, sineFit, color="red")
                     print(phase, sineFit)
-                    minPhasesBoundsIndices, maxPhasesBoundsIndices = getPhaseRangesNearPeak(getFoldedFitPeakValley(sineFit), phase)
-                    plotPhaseRangesNearPeak((minPhasesBoundsIndices, maxPhasesBoundsIndices), phase, ax=self.figureAxis)
+                    #minPhasesBoundsIndices, maxPhasesBoundsIndices = getPhaseRangesNearPeak(getFoldedFitPeakValley(sineFit), phase)
+                    #plotPhaseRangesNearPeak((minPhasesBoundsIndices, maxPhasesBoundsIndices), phase, ax=self.figureAxis)
                 except Exception as e:
                     print("Failed to get fit")
                     print(e)