generate_plots: fix formatting and star count

generate_latex_table.py

@@ -0,0 +1,84 @@
+import pandas as pd
+import numpy as np
+from main.astrodatagui.db.StarsDB import StarDB
+
+db: StarDB = StarDB.getInstance("stars.db")
+starMainIDs = db.getAllStars()
+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)
+    kicName = "-"
+    ticName = "-"
+    spType = "-"
+    for name in altNames:
+        if name[0].startswith("TIC"):
+            ticName = name[0]
+        if name[0].startswith("KIC"):
+            kicName = name[0]
+    spType = infos["SpType"]
+    
+    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}_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

@@ -1,3 +1,4 @@
+from math import comb
 import numpy as np
 import pandas as pd
 import itertools
@@ -9,6 +10,22 @@ from datetime import datetime
 from errno import EEXIST
 from os import makedirs, path
 import shutil
+import multiprocessing
+import concurrent.futures
+from concurrent.futures import wait, ALL_COMPLETED
+from functools import partial
+
+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 normalizePhase(phase, phaseMin = None, phaseMax = None):
     if(phaseMin is None):
@@ -27,52 +44,6 @@ def mkdir_p(mypath):
             pass
         else: raise
 
-fileName = "datav4.cff"
-data = pd.read_pickle(fileName)
-
-binList = [10, 20, 30]
-spType = ["M", "K", "G", "F"]
-
-useKepler = True
-useK2 = True
-useTESS = True
-
-showSourceFilter = np.full(len(data), False)
-if(useKepler):
-    showKepler = data["Source"] == "Kepler"
-    showSourceFilter |= showKepler
-if(useK2):
-    showK2 = data["Source"] == "K2"
-    showSourceFilter |= showK2
-if(useTESS):
-    showTESS = data["Source"] == "TESS"
-    showSourceFilter |= showTESS
-
-current = datetime.now()
-date = f"{current.year}-{current.month}-{current.day}"
-time = f"{current.hour}-{current.minute}-{current.second}"
-folderPath = f"../{date}/"
-#folderPath = f"G:/Meine Ablage/Masterthesis/{date}/"
-mkdir_p(folderPath)
-
-# remove any data that has no period
-data = data[(data["FitType"] == "sine") | (data["FitType"] == "poly")]
-
-# remove data with multiple minima/maxima present
-filterArray = []
-for ind, row in data.reset_index().iterrows():
-    if(len(row["pdcsapPeriodMinima"]) == len(row["pdcsapPeriodMaxima"]) and
-       len(row["pdcsapPeriodMinima"]) == 1):
-        filterArray.append(True)
-    else:
-        filterArray.append(False)
-
-filterArray = np.array(filterArray)
-data = data[filterArray]
-
-validStarPeriodMap = []
-starList = set(list(data["StarName"]))
-
 def allValuesWithin3Std(values: list):
     if(not values or len(values) == 1):
         return True
@@ -82,20 +53,7 @@ def allValuesWithin3Std(values: list):
 def getMeanPeriod(values: list):
     return np.mean(values)
 
-for starName in starList:
-    periods = list(data[data["StarName"] == starName]["pdcsapPeriod"])
-
-    validStarPeriodMap.append({"StarName": starName,
-                               "MeanPeriod": getMeanPeriod(periods),
-                               "PeriodWithinStd": allValuesWithin3Std(periods)})
-
-validStarPeriodMap = pd.DataFrame(validStarPeriodMap)
-periodsCutList = [0.5, 1, 1.5, 2, 5, 10, 15, 20]
-
-data = pd.merge(data, validStarPeriodMap, on="StarName")
-starDB: StarDB = StarDB.getInstance("stars.db")
-
-def plotBinsHistogram(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, bins, title, filename):
+def plotBinsHistogram(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, bins, title, filename, foldedFits):
     figHisto, ((axHisto)) = plt.subplots(nrows=1, ncols=1)
     y, binEdges, _ = axHisto.hist(PDCSAPdataList, bins,
                                   label=PDCSAPlabelList,
@@ -124,18 +82,27 @@ def plotBinsHistogram(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, bins, ti
         quit()
     axHisto.set_ylabel("Num. flares")
     axHisto.set_xlabel("Phase")
-    axHisto.set_title(title)
+    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):
         secAxisXdata = np.linspace(0, 2, num=10000)
         secAxisYdata = np.cos(secAxisXdata*np.pi) + 1
-    axHistoPhase.plot(secAxisXdata, secAxisYdata)
+        axHistoPhase.plot(secAxisXdata, secAxisYdata, color="blue")
         axHistoPhase.set_ylim(0, 7)
+    else:
+        for fit in foldedFits:
+            axHistoPhase.plot(fit[0], fit[1], color="blue")
+        fitCol = [fit[1] for fit in foldedFits]
+        fitCol = np.array(list(itertools.chain.from_iterable(fitCol)))
+        if(len(fitCol) == 0):
+            fitCol = np.array([0, 1])
+        axHistoPhase.set_ylim(np.min(fitCol), np.max(fitCol)*1.2)
 
-    plt.savefig(filename)
+    plt.savefig(filename, bbox_inches="tight")
     plt.close()
 
 def plotFlarePhasePeakHistogram(xData, yData, bins, maxY, title, filename):
@@ -151,26 +118,27 @@ def plotFlarePhasePeakHistogram(xData, yData, bins, maxY, title, filename):
     figFlarepeakHist.colorbar(im, label='Counts', ax=axFlarepeakHist)
     axFlarepeakHist.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
     axFlarepeakHist.xaxis.set_major_locator(MaxNLocator(5))
-    axFlarepeakHist.set_title(title)
-    plt.savefig(filename)
+    axFlarepeakHist.set_title(title, wrap=True)
+    plt.savefig(filename, bbox_inches="tight")
     plt.close()
 
 def plotFlarePeaks(plotdata, filters, labels, colors, maxY, title, filename):
     if(isinstance(labels, list) and isinstance(colors, list)):
         _, ((axFlarePeaks)) = plt.subplots(nrows=1, ncols=1)
         for f, l, c in zip(filters, labels, colors):
-            axFlarePeaks.scatter(plotdata[f]["PDCSAPNormPhase"],
-                                 plotdata[f]["Peak"],
+            axFlarePeaks.scatter(plotdata[f]["PDCSAPNormPhase"] if "PDCSAPNormPhase" in plotdata[f].columns else plotdata[f]["PDCSAPNormPhasePeriod"],
+                                 plotdata[f]["Peak"] if "Peak" in plotdata[f].columns else plotdata[f]["PeakPeriod"],
                                  label=l, color=c)
     elif(isinstance(labels, str) and isinstance(colors, str)):
         _, ((axFlarePeaks)) = plt.subplots(nrows=1, ncols=1)
         if(filters is None):
-            axFlarePeaks.scatter(plotdata[:]["PDCSAPNormPhase"],
-                                plotdata[:]["Peak"],
+            axFlarePeaks.scatter(plotdata[:]["PDCSAPNormPhase"] if "PDCSAPNormPhase" in plotdata[:].columns else plotdata[:]["PDCSAPNormPhasePeriod"],
+                                
+                                 plotdata[:]["Peak"] if "Peak" in plotdata[:].columns else plotdata[:]["PeakPeriod"],
                                 label=labels, color=colors)
         else:
-            axFlarePeaks.scatter(plotdata[filters]["PDCSAPNormPhase"],
-                                plotdata[filters]["Peak"],
+            axFlarePeaks.scatter(plotdata[filters]["PDCSAPNormPhase"] if "PDCSAPNormPhase" in plotdata[filters].columns else plotdata[filters]["PDCSAPNormPhasePeriod"],
+                                 plotdata[filters]["Peak"] if "Peak" in plotdata[filters].columns else plotdata[filters]["PeakPeriod"],
                                  label=labels, color=colors)
     else:
         return
@@ -178,15 +146,15 @@ def plotFlarePeaks(plotdata, filters, labels, colors, maxY, title, filename):
     axFlarePeaks.set_ylim(0.99, maxY)
     axFlarePeaks.set_ylabel("Flare peak")
     axFlarePeaks.set_xlabel("Phase")
-    axFlarePeaks.set_title(title)
+    axFlarePeaks.set_title(title, wrap=True)
     axFlarePeaks.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
     axFlarePeaks.xaxis.set_major_locator(MaxNLocator(5))
-    axFlarePeaks.legend()
-    plt.savefig(filename)
+    axFlarePeaks.legend(loc="lower right")
+    plt.savefig(filename, bbox_inches="tight")
     plt.close()
 
-def setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak,
-                                  PDCSAPdataList=None, dataFilter=None):
+def setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak, pdcsapbinningData,
+                           pdcsapbinningDataColumn, PDCSAPdataList=None, dataFilter=None):
     xData = pd.DataFrame()
     yData = pd.DataFrame()
     for aX, aY in zip(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak):
@@ -197,19 +165,20 @@ def setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak,
     yData = np.asarray(yData.values)[:,0]
     if(PDCSAPdataList is not None):
         if(dataFilter is not None):
-            PDCSAPdataList.append(pdcsapbinningData[dataFilter]["PDCSAPNormPhase"])
+            PDCSAPdataList.append(pdcsapbinningData[dataFilter][pdcsapbinningDataColumn])
         else:
-            PDCSAPdataList.append(pdcsapbinningData[:]["PDCSAPNormPhase"])
+            PDCSAPdataList.append(pdcsapbinningData[:][pdcsapbinningDataColumn])
 
     return xData, yData, PDCSAPdataList
 
 def generatePlots(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, histogramTitleArg, histogramFilenameArg,
                   xData, yData, peak2DHistogramTitleArg, peak2DfilenameArg,
-                  plotdata, filters, flarePlotLabels, flarePlotColors, flarePlotTitleArg, flarePlotFilenameArg):
+                  plotdata, filters, flarePlotLabels, flarePlotColors, flarePlotTitleArg, flarePlotFilenameArg,
+                  foldedFits=None):
     for bins in binList:
         histogramTitle = histogramTitleArg.replace("@bins", str(bins))
         histogramFilename = histogramFilenameArg.replace("@bins", str(bins))
-        plotBinsHistogram(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, bins, histogramTitle, histogramFilename)
+        plotBinsHistogram(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, bins, histogramTitle, histogramFilename, foldedFits)
 
         for maxY in [1.05, 1.1, 1.2, 1.5, 2, 2.5, 3, 5, max(yData)]:
             peak2DHistogramTitle = peak2DHistogramTitleArg.replace("@bins", str(bins))
@@ -221,8 +190,7 @@ def generatePlots(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, histogramTit
         flarePlotFilename = flarePlotFilenameArg.replace("@maxY", str(maxY))
         plotFlarePeaks(plotdata, filters, flarePlotLabels, flarePlotColors, maxY, flarePlotTitle, flarePlotFilename)
 
-# All stars
-for starName in starDB.getAllStars():
+def plotStar(data, showSourceFilter, folderPath, starName):
     finalData = pd.DataFrame()
     starNameR = starName.replace('*', '_star_')
     nameFilter = data["StarName"] == starName
@@ -230,10 +198,11 @@ for starName in starDB.getAllStars():
     finalData = pd.concat([finalData, data[nameFilter]], ignore_index=True)
 
     pdcsapbinningData = []
+    foldedFits = []
     locFolder = f"{folderPath}/stars/{starNameR}/"
     mkdir_p(f"{locFolder}/")
     csvFile = open(f"{locFolder}/{starNameR}.csv", "a")
-    csvFile.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Normalized Phase of Peak,Peak in Period")
+    csvFile.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Spot Modulation,Normalized Phase of Peak,Peak in Period")
     csvFile.write("\n")
     for ind, row in finalData.reset_index().iterrows():
         PDCSAPminOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][0]
@@ -243,13 +212,15 @@ for starName in starDB.getAllStars():
                 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(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{row['pdcsapSpotModulation']},{normPhase},{peak['FlarePeak']}")
                     csvFile.write("\n")
                     pdcsapbinningData.append({"SpType": f'{row["SpType"][0:2] if len(row["SpType"]) > 1 else row["SpType"][0]}',
                                             "PDCSAPNormPhase": normPhase,
                                             "Peak": peak["FlarePeak"]})
                     if(peak["FlarePeak"] > 100):
                         print(row["StarName"], "has over 100 peak")
+                foldedFits.append([normalizePhase(row["pdcsapFoldedFitPhase"]), row["pdcsapFoldedFit"]])
+              
     csvFile.close()
     pdcsapbinningData = pd.DataFrame(pdcsapbinningData)
     PDCSAPdataList = []
@@ -257,10 +228,7 @@ for starName in starDB.getAllStars():
     PDCSAPcolorList = []
     PDCSAPdataList2dhistPhase = []
     PDCSAPdataList2dhistPeak = []
-
-    if(len(pdcsapbinningData) < 1):
-        continue
-    else:
+    if(len(pdcsapbinningData) > 0):
         if(pdcsapbinningData["SpType"][0][0] == "M"):
             color = "red"
         elif(pdcsapbinningData["SpType"][0][0] == "K"):
@@ -275,22 +243,180 @@ for starName in starDB.getAllStars():
         PDCSAPdataList2dhistPhase.append(pdcsapbinningData[:]["PDCSAPNormPhase"])
         PDCSAPdataList2dhistPeak.append(pdcsapbinningData[:]["Peak"])
 
-    xData, yData, PDCSAPdataList = setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak, PDCSAPdataList)
+        xData, yData, PDCSAPdataList = setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak,
+                                                              pdcsapbinningData, "PDCSAPNormPhase",
+                                                              PDCSAPdataList)
+
+        PDCSAPcolorList.append(color)
+        generatePlots(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, f"Flare count in phase of {starName} with @bins bins", f"{locFolder}/{starNameR}-Flarecount-@bins_Bins.png",
+                        xData, yData, f"Flare peak per phase histogram of {starName} with @bins bins", f"{locFolder}/{starNameR}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
+                        pdcsapbinningData, None, f"{starName}", color, f"Flare peaks per phase of {starName}", f"{locFolder}/{starNameR}-Flarepeaks_maxY-@maxY.png",
+                        foldedFits)
+
+def plotStarPeriod(data, showSourceFilter, folderPath, starName):
+    finalData = pd.DataFrame()
+    starNameR = starName.replace('*', '_star_')
+    nameFilter = data["StarName"] == starName
+    nameFilter &= showSourceFilter
+    finalData = pd.concat([finalData, data[nameFilter]], ignore_index=True)
+
+    pdcsapbinningDataSpotModDiffPeriod = []
+    foldedPeriodFits = []
+    locFolder = f"{folderPath}/stars/{starNameR}/"
+    mkdir_p(f"{locFolder}/")
+    csvFile = open(f"{locFolder}/{starNameR}_Period.csv", "a")
+    csvFile.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Spot Modulation,Normalized Phase of Peak,Peak in Period")
+    csvFile.write("\n")
+    for ind, row in finalData.reset_index().iterrows():
+        PDCSAPminOrigPhase = row["pdcsapPeriodFoldedFitPhaseStarEnd"][0]
+        PDCSAPmaxOrigPhase = row["pdcsapPeriodFoldedFitPhaseStarEnd"][1]
+
+        if(len(row["pdcsapPeriodFoldedPeaksPhasePair"]) > 0):
+                pdcsapVals = pd.DataFrame(row["pdcsapPeriodFoldedPeaksPhasePair"])
+                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']},{row['pdcsapSpotModulation']},{normPhase},{peak['FlarePeak']}")
+                    csvFile.write("\n")
+                    pdcsapbinningDataSpotModDiffPeriod.append({"SpType": f'{row["SpType"][0:2] if len(row["SpType"]) > 1 else row["SpType"][0]}',
+                                            "PDCSAPNormPhasePeriod": normPhase,
+                                            "PeakPeriod": peak["FlarePeak"]})
+                    if(peak["FlarePeak"] > 100):
+                        print(row["StarName"], "has over 100 peak")
+                foldedPeriodFits.append([normalizePhase(row["pdcsapPeriodFoldedFitPhase"]), row["pdcsapPeriodFoldedFit"]])
+
+    csvFile.close()
+    pdcsapbinningDataSpotModDiffPeriod = pd.DataFrame(pdcsapbinningDataSpotModDiffPeriod) if len(pdcsapbinningDataSpotModDiffPeriod) > 0 else None
+
+    if(pdcsapbinningDataSpotModDiffPeriod is not None):
+        PDCSAPdataListPeriod = []
+        PDCSAPlabelList = []
+        PDCSAPcolorList = []
+        PDCSAPdataList2dhistPhase = []
+        PDCSAPdataList2dhistPeak = []
+
+        if(pdcsapbinningDataSpotModDiffPeriod["SpType"][0][0] == "M"):
+            color = "red"
+        elif(pdcsapbinningDataSpotModDiffPeriod["SpType"][0][0] == "K"):
+            color = "orange"
+        elif(pdcsapbinningDataSpotModDiffPeriod["SpType"][0][0] == "G"):
+            color = "yellow"
+        elif(pdcsapbinningDataSpotModDiffPeriod["SpType"][0][0] == "F"):
+            color = "greenyellow"
+        else:
+            color = "gray"
+
+        PDCSAPdataList2dhistPhase.append(pdcsapbinningDataSpotModDiffPeriod[:]["PDCSAPNormPhasePeriod"])
+        PDCSAPdataList2dhistPeak.append(pdcsapbinningDataSpotModDiffPeriod[:]["PeakPeriod"])
+
+        xData, yData, PDCSAPdataListPeriod = setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak,
+                                                                    pdcsapbinningDataSpotModDiffPeriod, "PDCSAPNormPhasePeriod",
+                                                                    PDCSAPdataListPeriod)
 
         PDCSAPlabelList.append(f"{starName}")
         PDCSAPcolorList.append(color)
 
-    plotdata = pdcsapbinningData
-    filters = None
-    flarePlotLabels = f"{starName}"
-    flarePlotColors = color
-    generatePlots(PDCSAPdataList, PDCSAPlabelList, PDCSAPcolorList, f"Flare count in phase of {starName} with @bins bins", f"{locFolder}/{starNameR}-Flarecount-@bins_Bins.png",
-                  xData, yData, f"Flare peak per phase histogram of {starName} with @bins bins", f"{locFolder}/{starNameR}-Flarepeaks-@bins_Bins_maxY-@maxY.png",
-                  plotdata, filters, flarePlotLabels, flarePlotColors, f"Flare peaks per phase of {starName}", f"{locFolder}/{starNameR}-Flarepeaks_maxY-@maxY.png")
+        generatePlots(PDCSAPdataListPeriod, PDCSAPlabelList, PDCSAPcolorList, f"Flare count in phase of {starName} with @bins bins", f"{locFolder}/{starNameR}-Flarecount-@bins_Bins_Period.png",
+                        xData, yData, f"Flare peak per phase histogram of {starName} with @bins bins", f"{locFolder}/{starNameR}-Flarepeaks-@bins_Bins_maxY-@maxY_Period.png",
+                        pdcsapbinningDataSpotModDiffPeriod, None, f"{starName}", color, f"Flare peaks per phase of {starName}", f"{locFolder}/{starNameR}-Flarepeaks_maxY-@maxY_Period.png",
+                        foldedPeriodFits)
+
+
+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 comboLength in range(1, len(spType) + 1):
-    for combo in itertools.combinations(spType, comboLength):
     for maxFlarePeak in [1.01, 1.05, 1.1, 1.25, 1.5]:
         # max Flare Peak cut
         finalDataMaxFlarePeak = pd.DataFrame()
@@ -311,14 +437,18 @@ for comboLength in range(1, len(spType) + 1):
             Ffilter &= showSourceFilter
             finalDataMaxFlarePeak = pd.concat([finalDataMaxFlarePeak, data[Ffilter]], ignore_index=True)
 
-            numStars = len(set(finalDataMaxFlarePeak["StarName"]))
-
-            pdcsapbinningData = []
-            locFolder = f"{folderPath}/{''.join(combo)}/maxFlarePeaks/{maxFlarePeak}/"
-            mkdir_p(f"{locFolder}/")
-            csvFile = open(f"{locFolder}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}.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")
+        pdcsapbinningDataU = []
+        pdcsapbinningDataO = []
+        locFolderU = f"{folderPath}/{''.join(combo)}/maxFlarePeaks/{maxFlarePeak}/"
+        locFolderO = f"{folderPath}/{''.join(combo)}/minFlarePeaks/{maxFlarePeak}/"
+        mkdir_p(f"{locFolderU}/")
+        mkdir_p(f"{locFolderO}/")
+        csvFileU = open(f"{locFolderU}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}.csv", "a")
+        csvFileU.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Normalized Phase of Peak,Peak in Period")
+        csvFileU.write("\n")
+        csvFileO = open(f"{locFolderO}/{''.join(combo)}_minFlarePeak_{maxFlarePeak}.csv", "a")
+        csvFileO.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Normalized Phase of Peak,Peak in Period")
+        csvFileO.write("\n")
         for ind, row in finalDataMaxFlarePeak.reset_index().iterrows():
             PDCSAPminOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][0]
             PDCSAPmaxOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][1]
@@ -327,161 +457,128 @@ for comboLength in range(1, len(spType) + 1):
                     for td, peak, pv in zip(pdcsapVals["Phase"], pdcsapVals["Peak"], row["pdcsapPeaks"]):
                         if(peak["FlarePeak"] <= maxFlarePeak):
                             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],
+                            csvFileU.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{normPhase},{peak['FlarePeak']}")
+                            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")
-
-            csvFile.close()
-            if(len(pdcsapbinningData) < 1):
-                continue
-            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)
-            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)}_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"{locFolder}/{''.join(combo)}_maxFlarePeak_{maxFlarePeak}-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)}_maxFlarePeak_{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"]):
+                        else:
                             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],
+                            csvFileO.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{normPhase},{peak['FlarePeak']}")
+                            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")
 
-        csvFile.close()
-        pdcsapbinningData = pd.DataFrame(pdcsapbinningData)
-        PDCSAPdataList = []
-        PDCSAPlabelList = []
-        PDCSAPcolorList = []
-        PDCSAPdataList2dhistPhase = []
-        PDCSAPdataList2dhistPeak = []
-        PDCSAPlabelList2dhist = []
-        PDCSAPcolorList2dhist = []
-        plotFilters = []
+        csvFileU.close()
+        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 = []
+            PDCSAPdataList2dhistPhaseU = []
+            PDCSAPdataList2dhistPeakU = []
+            plotFiltersU = []
             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)
+                Mfilter = pdcsapbinningDataU["SpType"] == "M"
+                PDCSAPdataList2dhistPhaseU.append(pdcsapbinningDataU[Mfilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakU.append(pdcsapbinningDataU[Mfilter]["Peak"])
+                PDCSAPdataListU.append(pdcsapbinningDataU[Mfilter]["PDCSAPNormPhase"])
+                PDCSAPlabelListU.append("M Stars")
+                PDCSAPcolorListU.append("red")
+                plotFiltersU.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)
+                Kfilter = pdcsapbinningDataU["SpType"] == "K"
+                PDCSAPdataList2dhistPhaseU.append(pdcsapbinningDataU[Kfilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakU.append(pdcsapbinningDataU[Kfilter]["Peak"])
+                PDCSAPdataListU.append(pdcsapbinningDataU[Kfilter]["PDCSAPNormPhase"])
+                PDCSAPlabelListU.append("K Stars")
+                PDCSAPcolorListU.append("orange")
+                plotFiltersU.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)
+                Gfilter = pdcsapbinningDataU["SpType"] == "G"
+                PDCSAPdataList2dhistPhaseU.append(pdcsapbinningDataU[Gfilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakU.append(pdcsapbinningDataU[Gfilter]["Peak"])
+                PDCSAPdataListU.append(pdcsapbinningDataU[Gfilter]["PDCSAPNormPhase"])
+                PDCSAPlabelListU.append("G Stars")
+                PDCSAPcolorListU.append("yellow")
+                plotFiltersU.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)
+                Ffilter = pdcsapbinningDataU["SpType"] == "F"
+                PDCSAPdataList2dhistPhaseU.append(pdcsapbinningDataU[Ffilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakU.append(pdcsapbinningDataU[Ffilter]["Peak"])
+                PDCSAPdataListU.append(pdcsapbinningDataU[Ffilter]["PDCSAPNormPhase"])
+                PDCSAPlabelListU.append("F Stars")
+                PDCSAPcolorListU.append("greenyellow")
+                plotFiltersU.append(Ffilter)
 
-        xData, yData, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak)
-        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")
+            xData, yData, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseU, PDCSAPdataList2dhistPeakU,
+                                                        pdcsapbinningDataU, "PDCSAPNormPhase")
+            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(comboLength == 1):
+        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 = []
+            PDCSAPdataList2dhistPhaseO = []
+            PDCSAPdataList2dhistPeakO = []
+            plotFiltersO = []
+            if("M" in combo):
+                Mfilter = pdcsapbinningDataO["SpType"] == "M"
+                PDCSAPdataList2dhistPhaseO.append(pdcsapbinningDataO[Mfilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakO.append(pdcsapbinningDataO[Mfilter]["Peak"])
+                PDCSAPdataListO.append(pdcsapbinningDataO[Mfilter]["PDCSAPNormPhase"])
+                PDCSAPlabelListO.append("M Stars")
+                PDCSAPcolorListO.append("red")
+                plotFiltersO.append(Mfilter)
+            if("K" in combo):
+                Kfilter = pdcsapbinningDataO["SpType"] == "K"
+                PDCSAPdataList2dhistPhaseO.append(pdcsapbinningDataO[Kfilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakO.append(pdcsapbinningDataO[Kfilter]["Peak"])
+                PDCSAPdataListO.append(pdcsapbinningDataO[Kfilter]["PDCSAPNormPhase"])
+                PDCSAPlabelListO.append("K Stars")
+                PDCSAPcolorListO.append("orange")
+                plotFiltersO.append(Kfilter)
+            if("G" in combo):
+                Gfilter = pdcsapbinningDataO["SpType"] == "G"
+                PDCSAPdataList2dhistPhaseO.append(pdcsapbinningDataO[Gfilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakO.append(pdcsapbinningDataO[Gfilter]["Peak"])
+                PDCSAPdataListO.append(pdcsapbinningDataO[Gfilter]["PDCSAPNormPhase"])
+                PDCSAPlabelListO.append("G Stars")
+                PDCSAPcolorListO.append("yellow")
+                plotFiltersO.append(Gfilter)
+            if("F" in combo):
+                Ffilter = pdcsapbinningDataO["SpType"] == "F"
+                PDCSAPdataList2dhistPhaseO.append(pdcsapbinningDataO[Ffilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakO.append(pdcsapbinningDataO[Ffilter]["Peak"])
+                PDCSAPdataListO.append(pdcsapbinningDataO[Ffilter]["PDCSAPNormPhase"])
+                PDCSAPlabelListO.append("F Stars")
+                PDCSAPcolorListO.append("greenyellow")
+                plotFiltersO.append(Ffilter)
+
+            xData, yData, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseO, PDCSAPdataList2dhistPeakO,
+                                                        pdcsapbinningDataO, "PDCSAPNormPhase")
+            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]
-            spTypes = [f"{mainSpType}0", f"{mainSpType}1", f"{mainSpType}2", f"{mainSpType}3", f"{mainSpType}4", f"{mainSpType}5", f"{mainSpType}6", f"{mainSpType}7", f"{mainSpType}8" f"{mainSpType}9"]
+        spTypes = [f"{mainSpType}0", f"{mainSpType}1", f"{mainSpType}2", f"{mainSpType}3", f"{mainSpType}4", f"{mainSpType}5", f"{mainSpType}6", f"{mainSpType}7", f"{mainSpType}8", f"{mainSpType}9"]
         match mainSpType:
             case "M":
                 color = "red"
@@ -496,7 +593,6 @@ for comboLength in range(1, len(spType) + 1):
             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)
 
@@ -517,11 +613,15 @@ for comboLength in range(1, len(spType) + 1):
                             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 = []
@@ -538,13 +638,15 @@ for comboLength in range(1, len(spType) + 1):
                 PDCSAPdataList2dhistPeak.append(pdcsapbinningData[SpTypefilter]["Peak"])
                 PDCSAPlabelList.append(f"{spTyp} Stars")
                 PDCSAPcolorList.append(color)
-                xData, yData, PDCSAPdataList = setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak, PDCSAPdataList, SpTypefilter)
+                xData, yData, PDCSAPdataList = setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak,
+                                                                        pdcsapbinningData, "PDCSAPNormPhase",
+                                                                        PDCSAPdataList, SpTypefilter)
 
                 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:
@@ -588,17 +690,19 @@ for comboLength in range(1, len(spType) + 1):
                     for td, peak, pv in zip(pdcsapVals["Phase"], pdcsapVals["Peak"], row["pdcsapPeaks"]):
                         normPhase = normalizePhase(td.value, np.abs(PDCSAPminOrigPhase), np.abs(PDCSAPmaxOrigPhase))
                         if(row["MeanPeriod"] <= periodCut):
-                                csvFileU.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{row["MeanPeriod"]},{normPhase},{peak['FlarePeak']}")
+                            csvFileU.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{row['MeanPeriod']},{normPhase},{peak['FlarePeak']}")
                             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(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()
@@ -626,6 +730,8 @@ for comboLength in range(1, len(spType) + 1):
             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"])
@@ -652,6 +758,8 @@ for comboLength in range(1, len(spType) + 1):
                 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"])
@@ -678,16 +786,94 @@ for comboLength in range(1, len(spType) + 1):
                 plotFiltersO.append(FfilterO)
 
         if(len(PDCSAPdataList2dhistPhaseU) > 0 and len(PDCSAPdataList2dhistPeakU) > 0):
-                xDataU, yDataU, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseU, PDCSAPdataList2dhistPeakU)
+            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)
+            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"]
+periodsCutList = [0.5, 1, 1.5, 2, 5, 10, 15, 20]
+
+if __name__ == "__main__":
+    fileName = "datav5.1.cff"
+    fullData = pd.read_pickle(fileName)
+    starDB: StarDB = StarDB.getInstance("stars.db")
+    allStars = starDB.getAllStars()
+
+    useKepler = True
+    useK2 = True
+    useTESS = True
+
+    current = datetime.now()
+    date = f"{current.year}-{current.month}-{current.day}"
+    time = f"{current.hour}-{current.minute}-{current.second}"
+
+    cpuCount = multiprocessing.cpu_count()
+    pool = multiprocessing.Pool(processes=cpuCount)
+
+    foldedFitTypes = ["sine", "poly"]
+    for foldedFitTypesLength in range(1, len(foldedFitTypes)+1):
+        for foldedFitTypeCombo in itertools.combinations(foldedFitTypes, foldedFitTypesLength):
+            folderPath = f"../{date}-{'-'.join(foldedFitTypeCombo)}/"
+            mkdir_p(folderPath)
+            foldedFitTypeComboFilter = np.full(len(fullData), False)
+            foldedFitTypeComboFilterPeriod = np.full(len(fullData), False)
+            if("sine" in foldedFitTypeCombo):
+                foldedFitTypeComboFilter |= fullData["FitType"] == "sine"
+                foldedFitTypeComboFilterPeriod |= fullData["periodFitType"] == "sine"
+            if("poly" in foldedFitTypeCombo):
+                foldedFitTypeComboFilter |= fullData["FitType"] == "poly"
+                foldedFitTypeComboFilterPeriod |= fullData["periodFitType"] == "poly"
+
+            data = fullData[(foldedFitTypeComboFilter) & (fullData["isValidFold"])]
+            dataPeriod = fullData[(foldedFitTypeComboFilterPeriod) & (fullData["isValidFold"])]
+
+            showSourceFilter = np.full(len(data), False)
+            if(useKepler):
+                showKepler = data["Source"] == "Kepler"
+                showSourceFilter |= showKepler
+            if(useK2):
+                showK2 = data["Source"] == "K2"
+                showSourceFilter |= showK2
+            if(useTESS):
+                showTESS = data["Source"] == "TESS"
+                showSourceFilter |= showTESS
+
+            validStarPeriodMap = []
+            starList = set(list(data["StarName"]))
+
+            for starName in starList:
+                periods = list(data[data["StarName"] == starName]["pdcsapPeriod"])
+
+                validStarPeriodMap.append({"StarName": starName,
+                                           "MeanPeriod": getMeanPeriod(periods),
+                                           "PeriodWithinStd": allValuesWithin3Std(periods)})
+
+            validStarPeriodMap = pd.DataFrame(validStarPeriodMap)
+
+            data = pd.merge(data, validStarPeriodMap, on="StarName")
+            
+            #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
+
+            combos = []
+            for comboLength in range(1, len(spType) + 1):
+                for combo in itertools.combinations(spType, comboLength):
+                    combos.append(combo)
+
+            plotComboFunc = partial(plotCombo, data, showSourceFilter, folderPath)
+            list(pool.map(plotComboFunc, combos)) # wrap in list, to force evaluation

main/astrodatagui/AstrodataGUI.py

@@ -42,6 +42,9 @@ class AstrodataGUI(QtWidgets.QMainWindow):
         self.cbPlotFlattenPlotEnable.stateChanged.connect(self.plotOptionsExclusiveCBChecked)
         self.cbPlotFoldEnable.stateChanged.connect(self.plotOptionsExclusiveCBChecked)
         self.cbPlotPeriodogramEnable.stateChanged.connect(self.plotOptionsExclusiveCBChecked)
+        self.cbPlotFoldShowSpotModulation.stateChanged.connect(self.plotOptionsCBChecked)
+        
+        self.gbPlotFoldOptimize.toggled.connect(self.plotOptionsCBChecked)
 
         self.comboPlotFluxType.currentTextChanged.connect(self.plotOptionsComboBoxTextChanged)
         self.comboPlotNormalizeUnit.currentTextChanged.connect(self.plotOptionsComboBoxTextChanged)
@@ -251,7 +254,10 @@ class AstrodataGUI(QtWidgets.QMainWindow):
             self.flaredetectorPreview.setFoldedFitType(self.foldedFitType)
 
     def updatePeriods(self, periods: list):
+        try:
             self.edPlotFoldPeriod.setText(str(periods[0].value))
+        except:
+            self.edPlotFoldPeriod.setText(str(periods[0]))
 
     def updateEpochPeriod(self, epoch: float):
         self.edPlotFoldEpochTime.setText(str(epoch))
@@ -281,6 +287,11 @@ class AstrodataGUI(QtWidgets.QMainWindow):
             case self.cbPlotBinEnable:
                 self.updateFlaredetectionWidgetBin()
 
+            case self.gbPlotFoldOptimize:
+                self.updateFlaredetectionWidgetFold()
+            case self.cbPlotFoldShowSpotModulation:
+                self.updateFlaredetectionWidgetFold()
+
     def plotOptionsExclusiveCBChecked(self, state):
         print(f"{self.sender().objectName()} is set to {state}")
         if(state == QtCore.Qt.Checked):
@@ -395,13 +406,16 @@ class AstrodataGUI(QtWidgets.QMainWindow):
 
     def updateFlaredetectionWidgetFold(self):
         foldEnabled = self.cbPlotFoldEnable.isChecked()
+        optimizeEnabled = self.gbPlotFoldOptimize.isChecked()
+        showSpotModulationEnabled = self.cbPlotFoldShowSpotModulation.isChecked()
+
         try:
             period = float(self.edPlotFoldPeriod.text())
             epoch = float(self.edPlotFoldEpochTime.text())
         except:
             print(f"Invalid period/epoch detected, aborting")
             return
-        self.flaredetectorPreview.setFoldState(foldEnabled, period, epoch)
+        self.flaredetectorPreview.setFoldState(foldEnabled, period, epoch, optimizeEnabled, showSpotModulationEnabled)
 
     def updateFlaredetectionWidgetPeriodogram(self):
         periodogramEnabled = self.cbPlotPeriodogramEnable.isChecked()

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'''
 
@@ -42,38 +54,19 @@ def getFlareCount(filesDict):
         mkdir_p(starFolder)
 
         lc = lk.read(filesDict["FilePath"])
-        lc.flux = lc["sap_flux"]
-        lc.flux_err = lc["sap_flux_err"]
-        lc = lc.normalize()
-        sapPeaks, sapFits = calculateFlareFitsForLightcurve(lc.flatten())
-        sapValSec, sapTds = getTotalValidDataInSeconds(lc, "sap_flux")
-        sapPeriodogram = lc.to_periodogram()
-        sapPeakPeriod = sapPeriodogram.period[findMaxIndices(sapPeriodogram, num=4, distance=100, sortByHighest=True)[0]]
-        sapEpochTime = getEpochTime(lc)
-        sapFoldedLC = lc.fold(period=sapPeakPeriod, epoch_time=sapEpochTime)
-        sapPhase, sapSineFit, sapFitType = getFoldedBestFit(sapFoldedLC, fitType=filesDict["FitType"])
-        sapMinima, sapMaxima = getFoldedFitPeakValley(sapSineFit)
-        sapminPhasesBounds, sapmaxPhasesBounds = getPhaseRangesNearPeak((sapMinima, sapMaxima), sapPhase, returnPhaseValue=True)
-        sapFoldedPeaks = []
-        sapFoldedPeaksPhasePair = []
-        for peak in sapPeaks:
-            cycle, foldedIndex = convertStarndardIndexToFoldedIndex(sapFoldedLC, peak["StandardIndex"])
-            sapFoldedPeaks.append({"Cycle: ": cycle, "Index": foldedIndex})
-            sapFoldedPeaksPhasePair.append({"Phase": sapFoldedLC.phase[sapFoldedLC.cycle == cycle][foldedIndex], "Peak": peak})
-
         lc.flux = lc["pdcsap_flux"]
         lc.flux_err = lc["pdcsap_flux_err"]
         lc = lc.normalize()
 
         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)
@@ -83,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()
@@ -95,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")
@@ -105,66 +98,75 @@ 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)
-        pdcsapFoldedLC = lc.fold(period=pdcsapPeakPeriod, epoch_time=pdcsapEpochTime)
-        pdcsapPhase, pdcsapSineFit, pdcsapFitType = getFoldedBestFit(pdcsapFoldedLC, fitType=filesDict["FitType"])
-        pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit)
-        pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True)
-        pdcsapFoldedPeaks = []
-        pdcsapFoldedPeaksPhasePair = []
-
-        pdcsapFoldedLC.scatter()
+        #pdcsapEpochTime = getEpochTime(lc)
+        #pdcsapFoldedLC = lc.fold(period=pdcsapPeakPeriod, epoch_time=pdcsapEpochTime)
+        #pdcsapPhase, pdcsapSineFit, pdcsapFitType = getFoldedBestFit(pdcsapFoldedLC, fitType=filesDict["FitType"])
+        optimizedFit = getOptimizedFold(lc.normalize(), filesDict["FitType"])
+        #pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit)
+        #pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True)
+        pdcsapFoldedPeaks = []; pdcsapPeriodFoldedPeaks = []
+        pdcsapFoldedPeaksPhasePair = []; pdcsapPeriodFoldedPeaksPhasePair = []
+        optimizedFit["foldedLC"].scatter()
         plt.title(f"{starName} - folded lightcurve")
-        plt.plot(pdcsapPhase, pdcsapSineFit, color="blue", label=f"{pdcsapFitType}-fit")
+        plt.plot(optimizedFit["phase"], optimizedFit["fit"], color="blue", label=f"{optimizedFit['fitType']}-fit")
         for peak in pdcsapPeaks:
-            cycle, foldedIndex = convertStarndardIndexToFoldedIndex(pdcsapFoldedLC, peak["StandardIndex"])
+            cycle, foldedIndex = convertStarndardIndexToFoldedIndex(optimizedFit["foldedLC"], peak["StandardIndex"])
             pdcsapFoldedPeaks.append({"Cycle: ": cycle, "Index": foldedIndex})
-            pdcsapFoldedPeaksPhasePair.append({"Phase": pdcsapFoldedLC.phase[pdcsapFoldedLC.cycle == cycle][foldedIndex], "Peak": peak})
-            plt.plot(pdcsapFoldedLC.phase[pdcsapFoldedLC.cycle == cycle][foldedIndex].value,
-                     pdcsapFoldedLC.flux[pdcsapFoldedLC.cycle == cycle][foldedIndex], "x", color="red")
+            pdcsapFoldedPeaksPhasePair.append({"Phase": optimizedFit["foldedLC"].phase[optimizedFit["foldedLC"].cycle == cycle][foldedIndex], "Peak": peak})
+            plt.plot(optimizedFit["foldedLC"].phase[optimizedFit["foldedLC"].cycle == cycle][foldedIndex].value,
+                     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):
+            optimizedFit["periodFoldedLC"].scatter()
+            plt.title(f"{starName} - folded lightcurve")
+            plt.plot(optimizedFit["periodFoldedPhase"], optimizedFit["periodFoldedFit"], color="blue", label=f"{optimizedFit['fitType']}-fit")
+            for peak in pdcsapPeaks:
+                cycle, foldedIndex = convertStarndardIndexToFoldedIndex(optimizedFit["periodFoldedLC"], peak["StandardIndex"])
+                pdcsapPeriodFoldedPeaks.append({"Cycle: ": cycle, "Index": foldedIndex})
+                pdcsapPeriodFoldedPeaksPhasePair.append({"Phase": optimizedFit["periodFoldedLC"].phase[optimizedFit["periodFoldedLC"].cycle == cycle][foldedIndex], "Peak": peak})
+                plt.plot(optimizedFit["periodFoldedLC"].phase[optimizedFit["periodFoldedLC"].cycle == cycle][foldedIndex].value,
+                         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", bbox_inches="tight")
+            plt.close()
         
-        filesDict["sapPeaks"] = sapPeaks
-        filesDict["sapPeaksCount"] = len(sapPeaks)
-        filesDict["sapFits"] = sapFits
-        filesDict["sapValidTimespans"] = sapTds
-        filesDict["sapValidSeconds"] = sapValSec
-        filesDict["sapFoldedCycle"] = sapFoldedLC.cycle
-        #filesDict["sapFoldedPhase"] = sapFoldedLC.phase.value
-        #filesDict["sapFoldedFitPhase"] = sapPhase
-        filesDict["sapFoldedFitPhaseStarEnd"] = (sapFoldedLC.phase.value[0], sapFoldedLC.phase.value[-1])
-        filesDict["sapFoldedPeaksPhasePair"] = sapFoldedPeaksPhasePair
-        filesDict["sapPeriod"] = sapPeakPeriod.value
-        filesDict["sapPeriodMinima"] = sapMinima
-        filesDict["sapPeriodMinimaBoundaries"] = sapminPhasesBounds
-        filesDict["sapPeriodMaxima"] = sapMaxima
-        filesDict["sapPeriodMaximaBoundaries"] = sapmaxPhasesBounds
         filesDict["pdcsapPeaks"] = pdcsapPeaks
         filesDict["pdcsapPeaksCount"] = len(pdcsapPeaks)
         filesDict["pdcsapFits"] = pdcsapFits
         filesDict["pdcsapValidTimespans"] = pdcsapTds
         filesDict["pdcsapValidSeconds"] = pdcsapValSec
-        filesDict["pdcsapFoldedCycle"] = sapFoldedLC.cycle
-        #filesDict["pdcsapFoldedPhase"] = sapFoldedLC.phase.value
-        #filesDict["pdcsapFoldedFitPhase"] = pdcsapPhase
-        filesDict["pdcsapFoldedFitPhaseStarEnd"] = (pdcsapFoldedLC.phase.value[0], pdcsapFoldedLC.phase.value[-1])
+        filesDict["pdcsapFoldedEpoch"] = optimizedFit["epoch"]
+        filesDict["pdcsapFoldedCycle"] = optimizedFit["foldedLC"].cycle
+        filesDict["pdcsapFoldedPhase"] = optimizedFit["foldedLC"].phase.value
+        filesDict["pdcsapFoldedFitPhase"] = optimizedFit["phase"]
+        filesDict["pdcsapFoldedFit"] = optimizedFit["fit"]
+        filesDict["pdcsapFoldedFitPhaseStarEnd"] = (optimizedFit["foldedLC"].phase.value[0], optimizedFit["foldedLC"].phase.value[-1])
         filesDict["pdcsapFoldedPeaksPhasePair"] = pdcsapFoldedPeaksPhasePair
-        filesDict["pdcsapPeriod"] = pdcsapPeakPeriod.value
-        filesDict["pdcsapPeriodMinima"] = pdcsapMinima
-        filesDict["pdcsapPeriodMinimaBoundaries"] = pdcsapminPhasesBounds
-        filesDict["pdcsapPeriodMaxima"] = pdcsapMaxima
-        filesDict["pdcsapPeriodMaximaBoundaries"] = pdcsapmaxPhasesBounds
+        filesDict["pdcsapPeriod"] = optimizedFit["Period"]
+        filesDict["pdcsapSpotModulation"] = optimizedFit["SpotModulation"]
+        filesDict['FitType'] = optimizedFit["fitType"]
+
+        filesDict["pdcsapPeriodFoldedCycle"] = optimizedFit["periodFoldedLC"].cycle if optimizedFit["periodFoldedLC"] is not None else None
+        filesDict["pdcsapPeriodFoldedPhase"] = optimizedFit["periodFoldedLC"].phase.value if optimizedFit["periodFoldedLC"] is not None else None
+        filesDict["pdcsapPeriodFoldedFitPhase"] = optimizedFit["periodFoldedPhase"]
+        filesDict["pdcsapPeriodFoldedFit"] = optimizedFit["periodFoldedFit"]
+        filesDict["pdcsapPeriodFoldedFitPhaseStarEnd"] = (optimizedFit["periodFoldedLC"].phase.value[0], optimizedFit["periodFoldedLC"].phase.value[-1]) if optimizedFit["periodFoldedLC"] is not None else (None, None)
+        filesDict["pdcsapPeriodFoldedPeaksPhasePair"] = pdcsapPeriodFoldedPeaksPhasePair
+        filesDict['periodFitType'] = optimizedFit["periodFitType"]
+
+        filesDict["isValidFold"] = optimizedFit["isValid"]
 
         csvFile = open(f"{starFolder}/{starNameR}_{source}-{sequence}.csv", "a")
         csvFile.write("StarName,Spectral Type,Rotational Velocity,Rotenional Velocity Unit,Distance,Distance Unit,Source,Sequence,File Path,Initial folded Fit Type,Used folded Fit Type")
-        csvFile.write(f"{filesDict['StarName']},{filesDict['SpType']},{filesDict['RotVel']},{filesDict['RotVelUnit']},{filesDict['Distance']},{filesDict['DistanceUnit']},{filesDict['Source']},{filesDict['Sequence']},{filesDict['FilePath']},{filesDict['FitType']},{pdcsapFitType}")
+        csvFile.write(f"{filesDict['StarName']},{filesDict['SpType']},{filesDict['RotVel']},{filesDict['RotVelUnit']},{filesDict['Distance']},{filesDict['DistanceUnit']},{filesDict['Source']},{filesDict['Sequence']},{filesDict['FilePath']},{filesDict['FitType']},{optimizedFit['fitType']}")
         csvFile.close()
         del lc
         print(f"Finished {filesDict['StarName']}, {filesDict['Sequence']}")

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/astrodatagui.ui

@@ -174,6 +174,21 @@
                <string>Sequences/Target Table ID</string>
               </property>
               <layout class="QHBoxLayout" name="horizontalLayout_5">
+               <property name="spacing">
+                <number>0</number>
+               </property>
+               <property name="leftMargin">
+                <number>0</number>
+               </property>
+               <property name="topMargin">
+                <number>0</number>
+               </property>
+               <property name="rightMargin">
+                <number>0</number>
+               </property>
+               <property name="bottomMargin">
+                <number>0</number>
+               </property>
                <item>
                 <layout class="QVBoxLayout" name="verticalLayout_2">
                  <item>
@@ -255,12 +270,39 @@
                <string>Plot options</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout_6">
+               <property name="spacing">
+                <number>0</number>
+               </property>
+               <property name="leftMargin">
+                <number>9</number>
+               </property>
+               <property name="topMargin">
+                <number>9</number>
+               </property>
+               <property name="rightMargin">
+                <number>9</number>
+               </property>
+               <property name="bottomMargin">
+                <number>9</number>
+               </property>
                <item>
                 <layout class="QHBoxLayout" name="horizontalLayout_4">
                  <item>
                   <layout class="QVBoxLayout" name="verticalLayout_10">
                    <item>
                     <layout class="QGridLayout" name="gridLayout_11">
+                     <property name="leftMargin">
+                      <number>9</number>
+                     </property>
+                     <property name="topMargin">
+                      <number>9</number>
+                     </property>
+                     <property name="rightMargin">
+                      <number>9</number>
+                     </property>
+                     <property name="bottomMargin">
+                      <number>9</number>
+                     </property>
                      <item row="0" column="0">
                       <widget class="QLabel" name="label_19">
                        <property name="sizePolicy">
@@ -284,12 +326,12 @@
                        </property>
                        <item>
                         <property name="text">
-                         <string>sap_flux</string>
+                         <string>pdcsap_flux</string>
                         </property>
                        </item>
                        <item>
                         <property name="text">
-                         <string>pdcsap_flux</string>
+                         <string>sap_flux</string>
                         </property>
                        </item>
                       </widget>
@@ -346,6 +388,21 @@
                       <string>Normalize</string>
                      </property>
                      <layout class="QGridLayout" name="gridLayout_6">
+                      <property name="leftMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="topMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="rightMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="bottomMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="spacing">
+                       <number>6</number>
+                      </property>
                       <item row="0" column="1">
                        <widget class="QLabel" name="label_12">
                         <property name="text">
@@ -412,6 +469,21 @@
                       <string>Remove Outliers</string>
                      </property>
                      <layout class="QGridLayout" name="gridLayout_8">
+                      <property name="leftMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="topMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="rightMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="bottomMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="spacing">
+                       <number>6</number>
+                      </property>
                       <item row="0" column="0">
                        <widget class="QCheckBox" name="cbPlotRemoveOutliersEnable">
                         <property name="text">
@@ -464,6 +536,21 @@
                       <string>Remove nans/infs</string>
                      </property>
                      <layout class="QGridLayout" name="gridLayout_10">
+                      <property name="leftMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="topMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="rightMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="bottomMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="spacing">
+                       <number>6</number>
+                      </property>
                       <item row="0" column="0">
                        <widget class="QCheckBox" name="cbPlotRemoveNansEnable">
                         <property name="sizePolicy">
@@ -522,6 +609,21 @@
                       <bool>false</bool>
                      </property>
                      <layout class="QGridLayout" name="gridLayout_5">
+                      <property name="leftMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="topMargin">
+                       <number>0</number>
+                      </property>
+                      <property name="rightMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="bottomMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="spacing">
+                       <number>6</number>
+                      </property>
                       <item row="0" column="1">
                        <widget class="QLabel" name="label_11">
                         <property name="text">
@@ -625,6 +727,21 @@
                       <string>Flatten</string>
                      </property>
                      <layout class="QGridLayout" name="gridLayout_7">
+                      <property name="leftMargin">
+                       <number>0</number>
+                      </property>
+                      <property name="topMargin">
+                       <number>0</number>
+                      </property>
+                      <property name="rightMargin">
+                       <number>0</number>
+                      </property>
+                      <property name="bottomMargin">
+                       <number>0</number>
+                      </property>
+                      <property name="spacing">
+                       <number>0</number>
+                      </property>
                       <item row="0" column="1">
                        <widget class="QLabel" name="label_14">
                         <property name="text">
@@ -706,84 +823,31 @@
                       <bool>false</bool>
                      </property>
                      <layout class="QGridLayout" name="gridLayout_3">
+                      <property name="leftMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="topMargin">
+                       <number>0</number>
+                      </property>
+                      <property name="rightMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="bottomMargin">
+                       <number>0</number>
+                      </property>
+                      <property name="spacing">
+                       <number>6</number>
+                      </property>
                       <item row="0" column="0">
                        <layout class="QGridLayout" name="gridLayout_2">
-                        <item row="2" column="0">
-                         <widget class="QLabel" name="label_8">
-                          <property name="sizePolicy">
-                           <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
-                            <horstretch>0</horstretch>
-                            <verstretch>0</verstretch>
-                           </sizepolicy>
-                          </property>
-                          <property name="minimumSize">
-                           <size>
-                            <width>60</width>
-                            <height>0</height>
-                           </size>
-                          </property>
-                          <property name="maximumSize">
-                           <size>
-                            <width>60</width>
-                            <height>16777215</height>
-                           </size>
-                          </property>
+                        <item row="0" column="1">
+                         <widget class="QLabel" name="label_10">
                           <property name="text">
-                           <string>Epoch Time: </string>
+                           <string>Enable</string>
                           </property>
                          </widget>
                         </item>
-                        <item row="1" column="0">
-                         <widget class="QLabel" name="label_7">
-                          <property name="sizePolicy">
-                           <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
-                            <horstretch>0</horstretch>
-                            <verstretch>0</verstretch>
-                           </sizepolicy>
-                          </property>
-                          <property name="minimumSize">
-                           <size>
-                            <width>60</width>
-                            <height>0</height>
-                           </size>
-                          </property>
-                          <property name="maximumSize">
-                           <size>
-                            <width>60</width>
-                            <height>16777215</height>
-                           </size>
-                          </property>
-                          <property name="text">
-                           <string>Period: </string>
-                          </property>
-                         </widget>
-                        </item>
-                        <item row="1" column="1">
-                         <widget class="QLineEdit" name="edPlotFoldPeriod">
-                          <property name="sizePolicy">
-                           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-                            <horstretch>0</horstretch>
-                            <verstretch>0</verstretch>
-                           </sizepolicy>
-                          </property>
-                          <property name="minimumSize">
-                           <size>
-                            <width>60</width>
-                            <height>0</height>
-                           </size>
-                          </property>
-                          <property name="maximumSize">
-                           <size>
-                            <width>60</width>
-                            <height>16777215</height>
-                           </size>
-                          </property>
-                          <property name="text">
-                           <string>1</string>
-                          </property>
-                         </widget>
-                        </item>
-                        <item row="2" column="1">
+                        <item row="4" column="1">
                          <widget class="QLineEdit" name="edPlotFoldEpochTime">
                           <property name="sizePolicy">
                            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
@@ -808,6 +872,31 @@
                           </property>
                          </widget>
                         </item>
+                        <item row="3" column="0">
+                         <widget class="QLabel" name="label_7">
+                          <property name="sizePolicy">
+                           <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+                            <horstretch>0</horstretch>
+                            <verstretch>0</verstretch>
+                           </sizepolicy>
+                          </property>
+                          <property name="minimumSize">
+                           <size>
+                            <width>60</width>
+                            <height>0</height>
+                           </size>
+                          </property>
+                          <property name="maximumSize">
+                           <size>
+                            <width>60</width>
+                            <height>16777215</height>
+                           </size>
+                          </property>
+                          <property name="text">
+                           <string>Period: </string>
+                          </property>
+                         </widget>
+                        </item>
                         <item row="0" column="0">
                          <widget class="QCheckBox" name="cbPlotFoldEnable">
                           <property name="text">
@@ -815,11 +904,76 @@
                           </property>
                          </widget>
                         </item>
-                        <item row="0" column="1">
-                         <widget class="QLabel" name="label_10">
-                          <property name="text">
-                           <string>Enable</string>
+                        <item row="3" column="1">
+                         <widget class="QLineEdit" name="edPlotFoldPeriod">
+                          <property name="sizePolicy">
+                           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+                            <horstretch>0</horstretch>
+                            <verstretch>0</verstretch>
+                           </sizepolicy>
                           </property>
+                          <property name="minimumSize">
+                           <size>
+                            <width>60</width>
+                            <height>0</height>
+                           </size>
+                          </property>
+                          <property name="maximumSize">
+                           <size>
+                            <width>60</width>
+                            <height>16777215</height>
+                           </size>
+                          </property>
+                          <property name="text">
+                           <string>1</string>
+                          </property>
+                         </widget>
+                        </item>
+                        <item row="4" column="0">
+                         <widget class="QLabel" name="label_8">
+                          <property name="sizePolicy">
+                           <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+                            <horstretch>0</horstretch>
+                            <verstretch>0</verstretch>
+                           </sizepolicy>
+                          </property>
+                          <property name="minimumSize">
+                           <size>
+                            <width>60</width>
+                            <height>0</height>
+                           </size>
+                          </property>
+                          <property name="maximumSize">
+                           <size>
+                            <width>60</width>
+                            <height>16777215</height>
+                           </size>
+                          </property>
+                          <property name="text">
+                           <string>Epoch Time: </string>
+                          </property>
+                         </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
+                         <widget class="QGroupBox" name="gbPlotFoldOptimize">
+                          <property name="title">
+                           <string>Optimize</string>
+                          </property>
+                          <property name="checkable">
+                           <bool>true</bool>
+                          </property>
+                          <property name="checked">
+                           <bool>false</bool>
+                          </property>
+                          <layout class="QHBoxLayout" name="horizontalLayout_8">
+                           <item>
+                            <widget class="QCheckBox" name="cbPlotFoldShowSpotModulation">
+                             <property name="text">
+                              <string>Show Spot Modulation</string>
+                             </property>
+                            </widget>
+                           </item>
+                          </layout>
                          </widget>
                         </item>
                        </layout>
@@ -856,6 +1010,21 @@
                       <string>Periodogram</string>
                      </property>
                      <layout class="QGridLayout" name="gridLayout_9">
+                      <property name="leftMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="topMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="rightMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="bottomMargin">
+                       <number>9</number>
+                      </property>
+                      <property name="spacing">
+                       <number>6</number>
+                      </property>
                       <item row="0" column="1">
                        <widget class="QLabel" name="label_20">
                         <property name="text">
@@ -966,6 +1135,21 @@
                <string>Star infos</string>
               </property>
               <layout class="QHBoxLayout" name="horizontalLayout_6">
+               <property name="spacing">
+                <number>0</number>
+               </property>
+               <property name="leftMargin">
+                <number>0</number>
+               </property>
+               <property name="topMargin">
+                <number>0</number>
+               </property>
+               <property name="rightMargin">
+                <number>0</number>
+               </property>
+               <property name="bottomMargin">
+                <number>0</number>
+               </property>
                <item>
                 <layout class="QGridLayout" name="gridLayout">
                  <item row="1" column="0">

main/astrodatagui/ui/FlaredetectorWidget.py

@@ -51,14 +51,14 @@ class FlaredetectorWidget(QtWidgets.QWidget):
         self.periodogramInfoGroupBox.setSizePolicy(sp)
         self.mainLayout.addWidget(self.periodogramInfoGroupBox)
 
-        self.fluxType = "sap_flux"
-        self.fluxErrType = "sap_flux_err"
+        self.fluxType = "pdcsap_flux"
+        self.fluxErrType = "pdcsap_flux_err"
         self.NormalizeState = {"Enabled": False, "Scale": "unscaled"}
         self.RemoveOutliersState = {"Enabled": False, "Sigma": 5.0}
         self.RemoveNansState = {"Enabled": False}
         self.BinState = {"Enabled": False, "Size": None}
         self.FlattenState = {"Enabled": False, "WindowLength": 101, "PolynomialOrder": 2}
-        self.FoldState = {"Enabled": False, "Period": 1, "EpochTime": 0}
+        self.FoldState = {"Enabled": False, "Period": 1, "EpochTime": 0, "Optimize": False, "spotModulation": False}
         self.PeriodogramState = {"Enabled": False, "Method": "lombscargle", "View": "frequency"}
         self.ShowQualityState = {"Enabled": False}
 
@@ -156,8 +156,10 @@ class FlaredetectorWidget(QtWidgets.QWidget):
         self.updateFit()
         self.updatePlot()
 
-    def setFoldState(self, enabled: bool, period: float, epoch: float):
+    def setFoldState(self, enabled: bool, period: float, epoch: float, optimize: bool, spotModulation: bool):
         self.FoldState["Enabled"] = enabled
+        self.FoldState["Optimize"] = optimize
+        self.FoldState["SpotModulation"] = spotModulation
         if(period < 0):
             print(f"Negative period detected, setting default 1")
             period = 1
@@ -246,6 +248,26 @@ class FlaredetectorWidget(QtWidgets.QWidget):
             lc = self.currentFlattenLC
             label += " - flattened"
         if(self.FoldState["Enabled"]):
+            if(self.FoldState["Optimize"]):
+                optimizedFold = getOptimizedFold(lc.normalize(), self.foldedFitType)
+                if(self.FoldState["SpotModulation"]):
+                    lc = optimizedFold["foldedLC"]
+                    self.periodsCalculated.emit([optimizedFold["SpotModulation"]])
+                    foldOptimizePhase = optimizedFold["phase"]
+                    foldOptimizeFit = optimizedFold["fit"]
+                elif(not self.FoldState["SpotModulation"] and optimizedFold["periodFoldedLC"] is not None):
+                    lc = optimizedFold["periodFoldedLC"]
+                    self.periodsCalculated.emit([optimizedFold["Period"]])
+                    foldOptimizePhase = optimizedFold["periodFoldedPhase"]
+                    foldOptimizeFit = optimizedFold["periodFoldedFit"]
+                else:
+                    lc = optimizedFold["foldedLC"]
+                    self.periodsCalculated.emit([optimizedFold["SpotModulation"]])
+                    foldOptimizePhase = optimizedFold["phase"]
+                    foldOptimizeFit = optimizedFold["fit"]
+                print("SpotModulation", self.FoldState["SpotModulation"])
+                self.epochCalculated.emit(optimizedFold["epoch"])
+            else:
                 lc = lc.fold(period=self.FoldState["Period"],
                              epoch_time=self.FoldState["EpochTime"])
             label += " - folded"
@@ -271,12 +293,16 @@ class FlaredetectorWidget(QtWidgets.QWidget):
                 cycle, foldedIndex = convertStarndardIndexToFoldedIndex(lc, peak["StandardIndex"])
                 self.figureAxis.plot(lc.phase[lc.cycle == cycle][foldedIndex].value,
                                      lc.flux[lc.cycle == cycle][foldedIndex], "x", color="red")
+            if(self.FoldState["Optimize"]):
+                self.figureAxis.plot(foldOptimizePhase, foldOptimizeFit, color="red")
+
+            else:
                 try:
                     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)

main/flaredetector/util.py

@@ -1,7 +1,8 @@
 import numpy as np
 from numpy.polynomial.polynomial import Polynomial
-from scipy.signal import find_peaks, argrelextrema
+from scipy.signal import find_peaks, argrelextrema, periodogram
 from scipy.optimize import curve_fit
+import itertools
 
 def findMaxIndices(lc, num=3, distance=100, height=(None, None), sortByHighest=False):
     if(hasattr(lc, "power")):
@@ -391,3 +392,105 @@ def plotPhaseRangesNearPeak(indices, phase, ax=None):
 
 def getEpochTime(lc):
     return lc.time.value[argrelextrema(np.asarray(lc.flux.value), np.less, order=500)[0]][0]
+
+def getOptimizedFold(normalizedLC, preferedFoldedFitType):
+    isValid = False
+
+    periodogramLS = normalizedLC.to_periodogram(method="lombscargle")
+    periodogramBLS = normalizedLC.to_periodogram(method="boxleastsquares")
+    
+    lsPeriods = periodogramLS.period[findMaxIndices(periodogramLS, num=4, distance=100, sortByHighest=True)]
+    blsPeriods = periodogramBLS.period[findMaxIndices(periodogramBLS, num=4, distance=100, sortByHighest=True)]
+
+    period = -100
+    spotModulation = -100
+    for lsP, blsP in itertools.product(lsPeriods, blsPeriods):
+        if(abs(lsP.value - blsP.value) < max(lsP.value, blsP.value)*0.05):
+            period = np.average([lsP.value, blsP.value])
+            print("Period found: ", period)
+            break
+    else:
+        print("No matching LS/BLS peak -> use highest LS")
+        period = lsPeriods[0].value
+
+    spotModulation = period
+    epoch = getEpochTime(normalizedLC)
+    tries = 0
+    periodFoldedLC = None
+    periodFoldedPhase = None
+    periodFoldedFit = None
+    periodFitType = None
+    while(tries < 30):
+        tries += 1
+        foldedLC = normalizedLC.fold(period=spotModulation, epoch_time=epoch)
+        phase, fit, fitType = getFoldedBestFit(foldedLC, fitType=preferedFoldedFitType)
+        phaseLength = abs(phase[0]) + abs(phase[-1])
+        fitMaximaArgs = argrelextrema(np.asarray(fit), np.greater)[0]
+        spotModulationBefore = spotModulation
+        if(len(fitMaximaArgs) > 1):
+            print("fitMaximaArgs > 1: ", fitMaximaArgs)
+            print(fitMaximaArgs[0], len(phase)*0.1, fitMaximaArgs[1], len(phase)*0.9)
+            print(fitMaximaArgs[0] > len(phase)*0.1, fitMaximaArgs[1] < len(phase)*0.9)
+            if(len(fitMaximaArgs) == 2 and fitMaximaArgs[0] > len(phase)*0.1 and fitMaximaArgs[1] < len(phase)*0.9):
+                halfPeriod = period/2
+                for lsP, blsP in zip(lsPeriods, blsPeriods):
+                    if(abs(lsP.value - halfPeriod) < period*0.05):
+                        spotModulation = lsP.value
+                        print("lsP.value", lsP.value)
+                        break
+                    elif(abs(blsP.value - halfPeriod) < period*0.05):
+                        spotModulation = blsP.value
+                        print("blsP.value", blsP.value)
+                        break
+                else:
+                    print("2 fit peaks, but no spot modulation")
+
+        if(spotModulationBefore != spotModulation):
+            periodFoldedLC = foldedLC
+            periodFoldedPhase = phase
+            periodFoldedFit = fit
+            periodFitType = fitType
+            foldedLC = normalizedLC.fold(period=spotModulation, epoch_time=epoch)
+            phase, fit, fitType = getFoldedBestFit(foldedLC, fitType=preferedFoldedFitType)
+            phaseLength = abs(phase[0]) + abs(phase[-1])
+
+        fitMinimaArgs = argrelextrema(np.asarray(fit), np.less)[0]
+        fitMinima = phase[0]
+        fitMinimaArg = 0
+
+        newFitMinimaArgs = []
+        for args in fitMinimaArgs:
+            print("Phases: ", fit[0], fit[len(phase)-1], fit[args])
+            if(fit[0] < fit[args] and fit[len(fit)-1] < fit[args]):
+                print("Found new minima")
+                newFitMinimaArgs.append(0)
+            newFitMinimaArgs.append(args)
+
+        newFitMinimaArgs = set(newFitMinimaArgs)
+        print(newFitMinimaArgs)
+
+        for args in newFitMinimaArgs:
+            if(abs(phase[args]) < abs(fitMinima) and fit[args] < fit[fitMinimaArg]):
+                fitMinima = phase[args]
+                fitMinimaArg = args
+
+        if(abs(fitMinima) < phaseLength*0.01):
+            isValid = True
+            break;
+        else:
+            epoch += fitMinima
+
+    return {"Period": period,
+            "SpotModulation": spotModulation,
+            "lsPeriods": lsPeriods,
+            "blsPeriods": blsPeriods,
+            "foldedLC": foldedLC,
+            "phase": phase,
+            "fit": fit,
+            "periodFoldedLC": periodFoldedLC,
+            "periodFoldedPhase": periodFoldedPhase,
+            "periodFoldedFit": periodFoldedFit,
+            "periodFitType": periodFitType,
+            "fitType": fitType,
+            "epoch": epoch,
+            "isValid": isValid}

show_unknown_sptype_stars.py

@@ -58,11 +58,11 @@ nonKicStars = pd.DataFrame(nonKicStars)
 print(kicNames)
 #print(nonKicStars)
 
-KeplerM = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/M-type-superflares.csv")
-KeplerK = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/K-type-superflares.csv")
-KeplerG = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/G-type-superflares.csv")
-KeplerF = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/F-type-superflares.csv")
-KeplerA = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/A-type-superflares.csv")
+#KeplerM = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/M-type-superflares.csv")
+#KeplerK = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/K-type-superflares.csv")
+#KeplerG = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/G-type-superflares.csv")
+#KeplerF = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/F-type-superflares.csv")
+#KeplerA = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/A-type-superflares.csv")
 
 #kicBasedSP = []
 #for fullKIC in kicNames["kicName"].values: