generate_plots: fix formatting and star count

also update SpType per Teff from
https://lweb.cfa.harvard.edu/~pberlind/atlas/htmls/note.html

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

@@ -0,0 +1,879 @@
+from math import comb
+import numpy as np
+import pandas as pd
+import itertools
+from main.astrodatagui.db.StarsDB import StarDB
+import matplotlib.ticker as tck
+from matplotlib.pyplot import MaxNLocator
+import matplotlib.pyplot as plt
+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):
+        phaseMin = np.abs(np.min(phase))
+    if(phaseMax is None):
+        phaseMax = np.abs(np.max(phase))
+    return (phase + phaseMin) / (phaseMin + phaseMax) * (2)
+
+def mkdir_p(mypath):
+    '''Creates a directory. equivalent to using mkdir -p on the command line'''
+
+    try:
+        makedirs(mypath)
+    except OSError as exc: # Python >2.5
+        if exc.errno == EEXIST and path.isdir(mypath):
+            pass
+        else: raise
+
+def allValuesWithin3Std(values: list):
+    if(not values or len(values) == 1):
+        return True
+
+    return max(values) - min(values) <= 3*np.std(values)
+
+def getMeanPeriod(values: list):
+    return np.mean(values)
+
+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,
+                                  color=PDCSAPcolorList,
+                                  stacked=True,
+                                  range=[0, 2])
+    bincenters = 0.5*(binEdges[1:]+binEdges[:-1])
+    if(isinstance(y[0], np.ndarray)):
+        y = y[-1]
+    n_i = y
+    m_i = bincenters * np.pi
+    N = np.sum(n_i)
+    mean = np.sum(n_i * m_i)/N
+    stdDev = np.sqrt(np.sum(((n_i - mean)**2)) / (N-1))
+    menStd = np.sqrt(y)
+    if(np.isinf(stdDev) or np.isnan(stdDev)):
+        stdDev = np.mean(menStd)
+        if(np.isinf(stdDev) or np.isnan(stdDev)):
+            stdDev = 0
+    axHisto.bar(bincenters[y > 0], y[y > 0], width=0, color='r', yerr=stdDev)
+    try:
+        axHisto.set_ylim(0, max(y) + stdDev)
+    except Exception as e:
+        print(e)
+        print(max(y), stdDev)
+        quit()
+    axHisto.set_ylabel("Num. flares")
+    axHisto.set_xlabel("Phase")
+    axHisto.set_title(title, wrap=True)
+    axHisto.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
+    axHisto.xaxis.set_major_locator(MaxNLocator(5))
+    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, 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, bbox_inches="tight")
+    plt.close()
+
+def plotFlarePhasePeakHistogram(xData, yData, bins, maxY, title, filename):
+    figFlarepeakHist, ((axFlarepeakHist)) = plt.subplots(nrows=1, ncols=1)
+    axFlarepeakHist.set_ylabel("Flare peak")
+    axFlarepeakHist.set_xlabel("Phase")
+    H, xedges, yedges = np.histogram2d(xData, yData, bins=bins, range=[[0, 2], [0.99, maxY]])
+    cmax = 11
+    H_clipped = np.clip(H, None, cmax)
+    im = axFlarepeakHist.imshow(H_clipped.T, origin='lower', interpolation='nearest',
+    extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]],
+    aspect='auto', cmap='viridis')
+    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, 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"] 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"] 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"] 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
+    axFlarePeaks.set_xlim(0, 2)
+    axFlarePeaks.set_ylim(0.99, maxY)
+    axFlarePeaks.set_ylabel("Flare peak")
+    axFlarePeaks.set_xlabel("Phase")
+    axFlarePeaks.set_title(title, wrap=True)
+    axFlarePeaks.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
+    axFlarePeaks.xaxis.set_major_locator(MaxNLocator(5))
+    axFlarePeaks.legend(loc="lower right")
+    plt.savefig(filename, bbox_inches="tight")
+    plt.close()
+
+def setupxyDataAndDataList(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak, pdcsapbinningData,
+                           pdcsapbinningDataColumn, PDCSAPdataList=None, dataFilter=None):
+    xData = pd.DataFrame()
+    yData = pd.DataFrame()
+    for aX, aY in zip(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak):
+        xData = pd.concat([xData, aX], ignore_index=True)
+        yData = pd.concat([yData, aY], ignore_index=True)
+
+    xData = np.asarray(xData.values)[:,0]
+    yData = np.asarray(yData.values)[:,0]
+    if(PDCSAPdataList is not None):
+        if(dataFilter is not None):
+            PDCSAPdataList.append(pdcsapbinningData[dataFilter][pdcsapbinningDataColumn])
+        else:
+            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,
+                  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, 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))
+            peak2Dfilename = peak2DfilenameArg.replace("@bins", str(bins)).replace("@maxY", str(maxY))
+            plotFlarePhasePeakHistogram(xData, yData, bins, maxY, peak2DHistogramTitle, peak2Dfilename)
+
+    for maxY in [1.05, 1.1, 1.2, 1.5, 2, 2.5, 3, 5, max(yData)]:
+        flarePlotTitle = flarePlotTitleArg
+        flarePlotFilename = flarePlotFilenameArg.replace("@maxY", str(maxY))
+        plotFlarePeaks(plotdata, filters, flarePlotLabels, flarePlotColors, maxY, flarePlotTitle, flarePlotFilename)
+
+def plotStar(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)
+
+    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,Spot Modulation,Normalized Phase of Peak,Peak in Period")
+    csvFile.write("\n")
+    for ind, row in finalData.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']},{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 = []
+    PDCSAPlabelList = []
+    PDCSAPcolorList = []
+    PDCSAPdataList2dhistPhase = []
+    PDCSAPdataList2dhistPeak = []
+    if(len(pdcsapbinningData) > 0):
+        if(pdcsapbinningData["SpType"][0][0] == "M"):
+            color = "red"
+        elif(pdcsapbinningData["SpType"][0][0] == "K"):
+            color = "orange"
+        elif(pdcsapbinningData["SpType"][0][0] == "G"):
+            color = "yellow"
+        elif(pdcsapbinningData["SpType"][0][0] == "F"):
+            color = "greenyellow"
+        else:
+            color = "gray"
+
+        PDCSAPdataList2dhistPhase.append(pdcsapbinningData[:]["PDCSAPNormPhase"])
+        PDCSAPdataList2dhistPeak.append(pdcsapbinningData[:]["Peak"])
+
+        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)
+
+        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 maxFlarePeak in [1.01, 1.05, 1.1, 1.25, 1.5]:
+        # max Flare Peak cut
+        finalDataMaxFlarePeak = pd.DataFrame()
+        if("M" in combo):
+            Mfilter = data["SpType"].str.startswith("M")
+            Mfilter &= showSourceFilter
+            finalDataMaxFlarePeak = pd.concat([finalDataMaxFlarePeak, data[Mfilter]], ignore_index=True)
+        if("K" in combo):
+            Kfilter = data["SpType"].str.startswith("K")
+            Kfilter &= showSourceFilter
+            finalDataMaxFlarePeak = pd.concat([finalDataMaxFlarePeak, data[Kfilter]], ignore_index=True)
+        if("G" in combo):
+            Gfilter = data["SpType"].str.startswith("G")
+            Gfilter &= showSourceFilter
+            finalDataMaxFlarePeak = pd.concat([finalDataMaxFlarePeak, data[Gfilter]], ignore_index=True)
+        if("F" in combo):
+            Ffilter = data["SpType"].str.startswith("F")
+            Ffilter &= showSourceFilter
+            finalDataMaxFlarePeak = pd.concat([finalDataMaxFlarePeak, data[Ffilter]], ignore_index=True)
+
+        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]
+            if(len(row["pdcsapFoldedPeaksPhasePair"]) > 0):
+                    pdcsapVals = pd.DataFrame(row["pdcsapFoldedPeaksPhasePair"])
+                    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))
+                            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"],
+                                                    "StarName": row['StarName']})
+                            if(peak["FlarePeak"] > 100):
+                                print(row["StarName"], "has over 100 peak")
+                        else:
+                            normPhase = normalizePhase(td.value, np.abs(PDCSAPminOrigPhase), np.abs(PDCSAPmaxOrigPhase))
+                            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"],
+                                                    "StarName": row['StarName']})
+                            if(peak["FlarePeak"] > 100):
+                                print(row["StarName"], "has over 100 peak")
+
+        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 = 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 = 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 = 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 = 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(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(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"]
+        match mainSpType:
+            case "M":
+                color = "red"
+            case "K":
+                color = "orange"
+            case "G":
+                color = "yellow"
+            case "F":
+                color = "greenyellow"
+             
+        for spTyp in spTypes:
+            finalDataAccSpTypes = pd.DataFrame()
+        
+            typeFilter = data["SpType"].str.startswith(spTyp)
+            typeFilter &= showSourceFilter
+            finalDataAccSpTypes = pd.concat([finalDataAccSpTypes, data[typeFilter]], ignore_index=True)
+
+            pdcsapbinningData = []
+            locFolder = f"{folderPath}/{spTyp}/"
+            mkdir_p(f"{locFolder}/")
+            csvFile = open(f"{locFolder}/{spTyp}.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 finalDataAccSpTypes.reset_index().iterrows():
+                PDCSAPminOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][0]
+                PDCSAPmaxOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][1]
+                if(len(row["pdcsapFoldedPeaksPhasePair"]) > 0):
+                        pdcsapVals = pd.DataFrame(row["pdcsapFoldedPeaksPhasePair"])
+                        for td, peak, pv in zip(pdcsapVals["Phase"], pdcsapVals["Peak"], row["pdcsapPeaks"]):
+                            normPhase = normalizePhase(td.value, np.abs(PDCSAPminOrigPhase), np.abs(PDCSAPmaxOrigPhase))
+                            csvFile.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{normPhase},{peak['FlarePeak']}")
+                            csvFile.write("\n")
+                            pdcsapbinningData.append({"SpType": f'{row["SpType"][0]}{row["SpType"][1]}',
+                                                    "PDCSAPNormPhase": normPhase,
+                                                    "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 = []
+                PDCSAPdataList2dhistPhase = []
+                PDCSAPdataList2dhistPeak = []
+                PDCSAPlabelList2dhist = []
+                PDCSAPcolorList2dhist = []
+                try:
+                    SpTypefilter = pdcsapbinningData["SpType"] == spTyp
+                except:
+                    shutil.rmtree(locFolder)
+                    continue
+                PDCSAPdataList2dhistPhase.append(pdcsapbinningData[SpTypefilter]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeak.append(pdcsapbinningData[SpTypefilter]["Peak"])
+                PDCSAPlabelList.append(f"{spTyp} Stars")
+                PDCSAPcolorList.append(color)
+                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 ({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:
+        finalDataPeriod = pd.DataFrame()
+        if("M" in combo):
+            Mfilter = data["SpType"].str.startswith("M")
+            Mfilter &= showSourceFilter
+            Mfilter &= data["PeriodWithinStd"] == True
+            finalDataPeriod = pd.concat([finalDataPeriod, data[Mfilter]], ignore_index=True)
+        if("K" in combo):
+            Kfilter = data["SpType"].str.startswith("K")
+            Kfilter &= showSourceFilter
+            Kfilter &= data["PeriodWithinStd"] == True
+            finalDataPeriod = pd.concat([finalDataPeriod, data[Kfilter]], ignore_index=True)
+        if("G" in combo):
+            Gfilter = data["SpType"].str.startswith("G")
+            Gfilter &= showSourceFilter
+            Gfilter &= data["PeriodWithinStd"] == True
+            finalDataPeriod = pd.concat([finalDataPeriod, data[Gfilter]], ignore_index=True)
+        if("F" in combo):
+            Ffilter = data["SpType"].str.startswith("F")
+            Ffilter &= showSourceFilter
+            Ffilter &= data["PeriodWithinStd"] == True
+            finalDataPeriod = pd.concat([finalDataPeriod, data[Ffilter]], ignore_index=True)
+        pdcsapbinningDataU = []
+        pdcsapbinningDataO = []
+        locFolder = f"{folderPath}/{''.join(combo)}/periodCuts/{periodCut}/"
+        mkdir_p(f"{locFolder}/")
+        csvFileU = open(f"{locFolder}/under_{periodCut}.csv", "a")
+        csvFileO = open(f"{locFolder}/over_{periodCut}.csv", "a")
+        csvFileU.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Mean Period,Normalized Phase of Peak,Peak in Period")
+        csvFileU.write("\n")
+        csvFileO.write("Star Name,Spectral Type,Source,File,Flare Time,Flare Peak,Period,Mean Period,Normalized Phase of Peak,Peak in Period")
+        csvFileO.write("\n")
+        for ind, row in finalDataPeriod.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))
+                        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("\n")
+                            pdcsapbinningDataU.append({"SpType": f'{row["SpType"][0]}',
+                                                        "PDCSAPNormPhase": normPhase,
+                                                        "Peak": peak["FlarePeak"],
+                                                        "StarName": row['StarName']})
+                        else:
+                            csvFileO.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{row['MeanPeriod']},{normPhase},{peak['FlarePeak']}")
+                            csvFileO.write("\n")
+                            pdcsapbinningDataO.append({"SpType": f'{row["SpType"][0]}',
+                                                        "PDCSAPNormPhase": normPhase,
+                                                        "Peak": peak["FlarePeak"],
+                                                        "StarName": row['StarName']})
+                        if(peak["FlarePeak"] > 100):
+                            print(row["StarName"], "has over 100 peak")
+        csvFileU.close()
+        csvFileO.close()
+        pdcsapbinningDataU = pd.DataFrame(pdcsapbinningDataU)
+        pdcsapbinningDataO = pd.DataFrame(pdcsapbinningDataO)
+        PDCSAPdataListU = []; PDCSAPdataListO = []
+        PDCSAPlabelList = []
+        PDCSAPcolorList = []
+        PDCSAPdataList2dhistPhaseU = []; PDCSAPdataList2dhistPeakU = []
+        PDCSAPdataList2dhistPhaseO = []; PDCSAPdataList2dhistPeakO = []
+        plotFiltersU = []; plotFiltersO = [];
+
+        if("M" in combo):
+            PDCSAPlabelList.append("M Stars")
+            PDCSAPcolorList.append("red")
+        if("K" in combo):
+            PDCSAPlabelList.append("K Stars")
+            PDCSAPcolorList.append("orange")
+        if("G" in combo):
+            PDCSAPlabelList.append("G Stars")
+            PDCSAPcolorList.append("yellow")
+        if("F" in combo):
+            PDCSAPlabelList.append("F Stars")
+            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"])
+                PDCSAPdataList2dhistPeakU.append(pdcsapbinningDataU[MfilterU]["Peak"])
+                PDCSAPdataListU.append(pdcsapbinningDataU[MfilterU]["PDCSAPNormPhase"])
+                plotFiltersU.append(MfilterU)
+            if("K" in combo):
+                KfilterU = pdcsapbinningDataU["SpType"] == "K"
+                PDCSAPdataList2dhistPhaseU.append(pdcsapbinningDataU[KfilterU]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakU.append(pdcsapbinningDataU[KfilterU]["Peak"])
+                PDCSAPdataListU.append(pdcsapbinningDataU[KfilterU]["PDCSAPNormPhase"])
+                plotFiltersU.append(KfilterU)
+            if("G" in combo):
+                GfilterU = pdcsapbinningDataU["SpType"] == "G"
+                PDCSAPdataList2dhistPhaseU.append(pdcsapbinningDataU[GfilterU]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakU.append(pdcsapbinningDataU[GfilterU]["Peak"])
+                PDCSAPdataListU.append(pdcsapbinningDataU[GfilterU]["PDCSAPNormPhase"])
+                plotFiltersU.append(GfilterU)
+            if("F" in combo):
+                FfilterU = pdcsapbinningDataU["SpType"] == "F"
+                PDCSAPdataList2dhistPhaseU.append(pdcsapbinningDataU[FfilterU]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakU.append(pdcsapbinningDataU[FfilterU]["Peak"])
+                PDCSAPdataListU.append(pdcsapbinningDataU[FfilterU]["PDCSAPNormPhase"])
+                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"])
+                PDCSAPdataList2dhistPeakO.append(pdcsapbinningDataO[MfilterO]["Peak"])
+                PDCSAPdataListO.append(pdcsapbinningDataO[MfilterO]["PDCSAPNormPhase"])
+                plotFiltersO.append(MfilterO)
+            if("K" in combo):
+                KfilterO = pdcsapbinningDataO["SpType"] == "K"
+                PDCSAPdataList2dhistPhaseO.append(pdcsapbinningDataO[KfilterO]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakO.append(pdcsapbinningDataO[KfilterO]["Peak"])
+                PDCSAPdataListO.append(pdcsapbinningDataO[KfilterO]["PDCSAPNormPhase"])
+                plotFiltersO.append(KfilterO)
+            if("G" in combo):
+                GfilterO = pdcsapbinningDataO["SpType"] == "G"
+                PDCSAPdataList2dhistPhaseO.append(pdcsapbinningDataO[GfilterO]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakO.append(pdcsapbinningDataO[GfilterO]["Peak"])
+                PDCSAPdataListO.append(pdcsapbinningDataO[GfilterO]["PDCSAPNormPhase"])
+                plotFiltersO.append(GfilterO)
+            if("F" in combo):
+                FfilterO = pdcsapbinningDataO["SpType"] == "F"
+                PDCSAPdataList2dhistPhaseO.append(pdcsapbinningDataO[FfilterO]["PDCSAPNormPhase"])
+                PDCSAPdataList2dhistPeakO.append(pdcsapbinningDataO[FfilterO]["Peak"])
+                PDCSAPdataListO.append(pdcsapbinningDataO[FfilterO]["PDCSAPNormPhase"])
+                plotFiltersO.append(FfilterO)
+
+        if(len(PDCSAPdataList2dhistPhaseU) > 0 and len(PDCSAPdataList2dhistPeakU) > 0):
+            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, {numStarsPeriodU} stars)", f"{locFolder}/{''.join(combo)}-Flarecount-Period_u_{periodCut}-@bins_Bins.png",
+                                xDataU, yDataU, f"Flare peak per phase histogram of {', '.join(combo)} type stars with @bins bins (Rot. Period under {periodCut} days, {numStarsPeriodU} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_u_{periodCut}-@bins_Bins_maxY-@maxY.png",
+                                pdcsapbinningDataU, plotFiltersU, PDCSAPlabelList, PDCSAPcolorList, f"Flare peaks per phase of {', '.join(combo)} type stars (Rot. Period under {periodCut} days, {numStarsPeriodU} stars)", f"{locFolder}/{''.join(combo)}-Flarepeaks-Period_u_{periodCut}-maxY_@maxY.png")
+
+        if(len(PDCSAPdataList2dhistPhaseO) > 0 and len(PDCSAPdataList2dhistPeakO) > 0):
+            xDataO, yDataO, _ = setupxyDataAndDataList(PDCSAPdataList2dhistPhaseO, PDCSAPdataList2dhistPeakO,
+                                                        pdcsapbinningDataO, "PDCSAPNormPhase",)
+            if(len(PDCSAPdataListO) > 0 and len(xDataO) > 0 and len(yDataO) > 0):
+                generatePlots(PDCSAPdataListO, PDCSAPlabelList, PDCSAPcolorList, f"Flare count per phase of {', '.join(combo)} type stars with @bins bins (Rot. Period over {periodCut} days, {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

generate_plots_MKGF.py

@@ -1,373 +0,0 @@
-import numpy as np
-import pandas as pd
-import itertools
-from main.astrodatagui.db.StarsDB import StarDB
-import matplotlib.ticker as tck
-from matplotlib.pyplot import MaxNLocator
-import matplotlib.pyplot as plt
-from datetime import datetime
-from errno import EEXIST
-from os import makedirs, path
-import shutil
-
-def normalizePhase(phase, phaseMin = None, phaseMax = None):
-    if(phaseMin is None):
-        phaseMin = np.abs(np.min(phase))
-    if(phaseMax is None):
-        phaseMax = np.abs(np.max(phase))
-    return (phase + phaseMin) / (phaseMin + phaseMax) * (2)
-
-def mkdir_p(mypath):
-    '''Creates a directory. equivalent to using mkdir -p on the command line'''
-
-    try:
-        makedirs(mypath)
-    except OSError as exc: # Python >2.5
-        if exc.errno == EEXIST and path.isdir(mypath):
-            pass
-        else: raise
-
-fileName = "datav3.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)
-
-for comboLength in range(1, len(spType) + 1):
-    for combo in itertools.combinations(spType, comboLength):
-        finalData = pd.DataFrame()
-        if("M" in combo):
-            Mfilter = data["SpType"].str.startswith("M")
-            Mfilter &= showSourceFilter
-            finalData = pd.concat([finalData, data[Mfilter]], ignore_index=True)
-        if("K" in combo):
-            Kfilter = data["SpType"].str.startswith("K")
-            Kfilter &= showSourceFilter
-            finalData = pd.concat([finalData, data[Kfilter]], ignore_index=True)
-        if("G" in combo):
-            Gfilter = data["SpType"].str.startswith("G")
-            Gfilter &= showSourceFilter
-            finalData = pd.concat([finalData, data[Gfilter]], ignore_index=True)
-        if("F" in combo):
-            Ffilter = data["SpType"].str.startswith("F")
-            Ffilter &= showSourceFilter
-            finalData = pd.concat([finalData, data[Ffilter]], ignore_index=True)
-
-
-
-        numStars = len(set(finalData["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 finalData.reset_index().iterrows():
-            PDCSAPminOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][0]
-            PDCSAPmaxOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][1]
-            if(len(row["pdcsapFoldedPeaksPhasePair"]) > 0):
-                    pdcsapVals = pd.DataFrame(row["pdcsapFoldedPeaksPhasePair"])
-                    for td, peak, pv in zip(pdcsapVals["Phase"], pdcsapVals["Peak"], row["pdcsapPeaks"]):
-                        normPhase = normalizePhase(td.value, np.abs(PDCSAPminOrigPhase), np.abs(PDCSAPmaxOrigPhase))
-                        csvFile.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{normPhase},{peak['FlarePeak']}")
-                        csvFile.write("\n")
-                        pdcsapbinningData.append({"SpType": row["SpType"][0],
-                                              "PDCSAPNormPhase": normPhase,
-                                              "Peak": peak["FlarePeak"]})
-                        if(peak["FlarePeak"] > 100):
-                            print(row["StarName"], "has over 100 peak")
-
-        csvFile.close()
-        pdcsapbinningData = pd.DataFrame(pdcsapbinningData)
-        PDCSAPdataList = []
-        PDCSAPlabelList = []
-        PDCSAPcolorList = []
-        PDCSAPdataList2dhistPhase = []
-        PDCSAPdataList2dhistPeak = []
-        PDCSAPlabelList2dhist = []
-        PDCSAPcolorList2dhist = []
-        if("M" in combo):
-            Mfilter = pdcsapbinningData["SpType"] == "M"
-            PDCSAPdataList2dhistPhase.append(pdcsapbinningData[Mfilter]["PDCSAPNormPhase"])
-            PDCSAPdataList2dhistPeak.append(pdcsapbinningData[Mfilter]["Peak"])
-            PDCSAPlabelList2dhist.append("M Stars")
-            PDCSAPcolorList2dhist.append("red")
-
-            PDCSAPdataList.append(pdcsapbinningData[Mfilter]["PDCSAPNormPhase"])
-            PDCSAPlabelList.append("M Stars")
-            PDCSAPcolorList.append("red")
-        if("K" in combo):
-            Kfilter = pdcsapbinningData["SpType"] == "K"
-            PDCSAPdataList2dhistPhase.append(pdcsapbinningData[Kfilter]["PDCSAPNormPhase"])
-            PDCSAPdataList2dhistPeak.append(pdcsapbinningData[Kfilter]["Peak"])
-            PDCSAPlabelList2dhist.append("K Stars")
-            PDCSAPcolorList2dhist.append("orange")
-
-            PDCSAPdataList.append(pdcsapbinningData[Kfilter]["PDCSAPNormPhase"])
-            PDCSAPlabelList.append("K Stars")
-            PDCSAPcolorList.append("orange")
-        if("G" in combo):
-            Gfilter = pdcsapbinningData["SpType"] == "G"
-            PDCSAPdataList2dhistPhase.append(pdcsapbinningData[Gfilter]["PDCSAPNormPhase"])
-            PDCSAPdataList2dhistPeak.append(pdcsapbinningData[Gfilter]["Peak"])
-            PDCSAPlabelList2dhist.append("G Stars")
-            PDCSAPcolorList2dhist.append("yellow")
-
-            PDCSAPdataList.append(pdcsapbinningData[Gfilter]["PDCSAPNormPhase"])
-            PDCSAPlabelList.append("G Stars")
-            PDCSAPcolorList.append("yellow")
-        if("F" in combo):
-            Ffilter = pdcsapbinningData["SpType"] == "F"
-            PDCSAPdataList2dhistPhase.append(pdcsapbinningData[Ffilter]["PDCSAPNormPhase"])
-            PDCSAPdataList2dhistPeak.append(pdcsapbinningData[Ffilter]["Peak"])
-            PDCSAPlabelList2dhist.append("F Stars")
-            PDCSAPcolorList2dhist.append("greenyellow")
-
-            PDCSAPdataList.append(pdcsapbinningData[Ffilter]["PDCSAPNormPhase"])
-            PDCSAPlabelList.append("F Stars")
-            PDCSAPcolorList.append("greenyellow")
-
-        xData = pd.DataFrame()
-        yData = pd.DataFrame()
-        for aX, aY in zip(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak):
-            xData = pd.concat([xData, aX], ignore_index=True)
-            yData = pd.concat([yData, aY], ignore_index=True)
-
-        xData = np.asarray(xData.values)[:,0]
-        yData = np.asarray(yData.values)[:,0]
-
-        for bins in binList:
-            figHisto, ((axHisto)) = plt.subplots(nrows=1, ncols=1)
-            y, binEdges, _ = axHisto.hist(PDCSAPdataList, bins,
-                                          label=PDCSAPlabelList,
-                                          color=PDCSAPcolorList,
-                                          stacked=True,
-                                          range=[0, 2])
-            bincenters = 0.5*(binEdges[1:]+binEdges[:-1])
-            if(isinstance(y[0], np.ndarray)):
-                y = y[-1]
-            n_i = y
-            m_i = bincenters * np.pi
-            N = np.sum(n_i)
-            mean = np.sum(n_i * m_i)/N
-            stdDev = np.sqrt(np.sum(((n_i - mean)**2)) / (N-1))
-            menStd = np.sqrt(y)
-            axHisto.bar(bincenters[y > 0], y[y > 0], width=0, color='r', yerr=stdDev)
-            axHisto.set_ylim(0, max(y) + stdDev)
-            axHisto.set_ylabel("Num. flares")
-            axHisto.set_xlabel("Phase")
-            axHisto.set_title(f"Flare count per phase of {', '.join(combo)} type stars with {bins} bins ({numStars} stars)")
-            axHisto.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
-            axHisto.xaxis.set_major_locator(MaxNLocator(5))
-            axHisto.legend()
-
-            axHistoPhase = axHisto.twinx()
-            secAxisXdata = np.linspace(0, 2, num=10000)
-            secAxisYdata = np.cos(secAxisXdata*np.pi) + 1
-            axHistoPhase.plot(secAxisXdata, secAxisYdata)
-            axHistoPhase.set_ylim(0, 7)
-            
-            plt.savefig(f"{locFolder}/{''.join(combo)}-Flarecount-{bins}_Bins.png")
-            plt.close()
-
-            for maxY in [1.05, 1.1, 1.2, 1.5, 2, 2.5, 3, 5, max(yData)]:
-                figFlarepeakHist, ((axFlarepeakHist)) = plt.subplots(nrows=1, ncols=1)
-                axFlarepeakHist.set_ylabel("Flare peak")
-                axFlarepeakHist.set_xlabel("Phase")
-                axFlarepeakHist.set_title(f"Flare peak per phase histogram of {', '.join(combo)} type stars with {bins} bins ({numStars} stars)")
-                H, xedges, yedges = np.histogram2d(xData, yData, bins=bins, range=[[0, 2], [0.99, maxY]])
-                cmax = 11
-                H_clipped = np.clip(H, None, cmax)
-                im = axFlarepeakHist.imshow(H_clipped.T, origin='lower', interpolation='nearest',
-                                extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]],
-                                aspect='auto', cmap='viridis')
-                figFlarepeakHist.colorbar(im, label='Counts', ax=axFlarepeakHist)
-                axFlarepeakHist.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
-                axFlarepeakHist.xaxis.set_major_locator(MaxNLocator(5))
-                plt.savefig(f"{locFolder}/{''.join(combo)}-Flarepeaks-{bins}_Bins_maxY-{maxY}.png")
-                plt.close()
-
-        for maxY in [1.05, 1.1, 1.2, 1.5, 2, 2.5, 3, 5, max(yData)]:
-            figFlarePeaks, ((axFlarePeaks)) = plt.subplots(nrows=1, ncols=1)
-            axFlarePeaks.set_title(f"Flare peaks per phase of {', '.join(combo)} type stars ({numStars} stars)")
-            if("M" in combo):
-                axFlarePeaks.scatter(pdcsapbinningData[Mfilter]["PDCSAPNormPhase"],
-                                     pdcsapbinningData[Mfilter]["Peak"],
-                                     label="M Stars", color="red")
-            if("K" in combo):
-                axFlarePeaks.scatter(pdcsapbinningData[Kfilter]["PDCSAPNormPhase"],
-                                     pdcsapbinningData[Kfilter]["Peak"],
-                                     label="K Stars", color="orange")
-            if("G" in combo):
-                axFlarePeaks.scatter(pdcsapbinningData[Gfilter]["PDCSAPNormPhase"],
-                                     pdcsapbinningData[Gfilter]["Peak"],
-                                     label="G Stars", color="yellow")
-            if("F" in combo):
-                axFlarePeaks.scatter(pdcsapbinningData[Ffilter]["PDCSAPNormPhase"],
-                                     pdcsapbinningData[Ffilter]["Peak"],
-                                     label="F Stars", color="greenyellow")
-            axFlarePeaks.set_xlim(0, 2)
-            axFlarePeaks.set_ylim(0.99, maxY)
-            axFlarePeaks.set_ylabel("Flare peak")
-            axFlarePeaks.set_xlabel("Phase")
-            axFlarePeaks.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
-            axFlarePeaks.xaxis.set_major_locator(MaxNLocator(5))
-            axFlarePeaks.legend()
-        
-            plt.savefig(f"{locFolder}/{''.join(combo)}-Flarepeaks_maxY-{maxY}.png")
-            plt.close()
-
-for sT, color in zip(["M", "K", "G", "F"], ["red", "orange", "yellow", "greenyellow"]):
-    spTypes = [f"{sT}0", f"{sT}1", f"{sT}2", f"{sT}3", f"{sT}4", f"{sT}5", f"{sT}6", f"{sT}7", f"{sT}8", f"{sT}9"]
-    for spTyp in spTypes:
-        finalData = pd.DataFrame()
-        
-        Mfilter = data["SpType"].str.startswith(spTyp)
-        numStars = len(set(data[Mfilter]["StarName"]))
-        Mfilter &= showSourceFilter
-        finalData = pd.concat([finalData, data[Mfilter]], ignore_index=True)
-
-        pdcsapbinningData = []
-        locFolder = f"{folderPath}/{spTyp}/"
-        mkdir_p(f"{locFolder}/")
-        csvFile = open(f"{locFolder}/{spTyp}.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 finalData.reset_index().iterrows():
-            PDCSAPminOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][0]
-            PDCSAPmaxOrigPhase = row["pdcsapFoldedFitPhaseStarEnd"][1]
-            if(len(row["pdcsapFoldedPeaksPhasePair"]) > 0):
-                    pdcsapVals = pd.DataFrame(row["pdcsapFoldedPeaksPhasePair"])
-                    for td, peak, pv in zip(pdcsapVals["Phase"], pdcsapVals["Peak"], row["pdcsapPeaks"]):
-                        normPhase = normalizePhase(td.value, np.abs(PDCSAPminOrigPhase), np.abs(PDCSAPmaxOrigPhase))
-                        csvFile.write(f"{row['StarName']},{row['SpType']},{row['Source']},{row['FilePath']},{pv['FlarePeakTime']},{pv['FlarePeak']},{row['pdcsapPeriod']},{normPhase},{peak['FlarePeak']}")
-                        csvFile.write("\n")
-                        pdcsapbinningData.append({"SpType": f'{row["SpType"][0]}{row["SpType"][1]}',
-                                              "PDCSAPNormPhase": normPhase,
-                                              "Peak": peak["FlarePeak"]})
-                        if(peak["FlarePeak"] > 100):
-                            print(row["StarName"], "has over 100 peak")
-        csvFile.close()
-        pdcsapbinningData = pd.DataFrame(pdcsapbinningData)
-        PDCSAPdataList = []
-        PDCSAPlabelList = []
-        PDCSAPcolorList = []
-        PDCSAPdataList2dhistPhase = []
-        PDCSAPdataList2dhistPeak = []
-        PDCSAPlabelList2dhist = []
-        PDCSAPcolorList2dhist = []
-        try:
-            SpTypefilter = pdcsapbinningData["SpType"] == spTyp
-        except:
-            shutil.rmtree(locFolder)
-            continue
-
-        PDCSAPdataList2dhistPhase.append(pdcsapbinningData[SpTypefilter]["PDCSAPNormPhase"])
-        PDCSAPdataList2dhistPeak.append(pdcsapbinningData[SpTypefilter]["Peak"])
-        PDCSAPlabelList2dhist.append(f"{spTyp} Stars")
-        PDCSAPcolorList2dhist.append(color)
-
-        xData = pd.DataFrame()
-        yData = pd.DataFrame()
-        for aX, aY in zip(PDCSAPdataList2dhistPhase, PDCSAPdataList2dhistPeak):
-            xData = pd.concat([xData, aX], ignore_index=True)
-            yData = pd.concat([yData, aY], ignore_index=True)
-
-        xData = np.asarray(xData.values)[:,0]
-        yData = np.asarray(yData.values)[:,0]
-        PDCSAPdataList.append(pdcsapbinningData[SpTypefilter]["PDCSAPNormPhase"])
-
-        PDCSAPlabelList.append(f"{spTyp} Stars")
-        PDCSAPcolorList.append(color)
-
-        for bins in binList:
-            figHisto, ((axHisto)) = plt.subplots(nrows=1, ncols=1)
-            y, binEdges, _ = axHisto.hist(PDCSAPdataList, bins,
-                                          label=PDCSAPlabelList,
-                                          color=PDCSAPcolorList,
-                                          stacked=True,
-                                          range=[0, 2])
-            bincenters = 0.5*(binEdges[1:]+binEdges[:-1])
-            if(isinstance(y[0], np.ndarray)):
-                y = y[-1]
-            n_i = y
-            m_i = bincenters * np.pi
-            N = np.sum(n_i)
-            mean = np.sum(n_i * m_i)/N
-            stdDev = np.sqrt(np.sum(((n_i - mean)**2)) / (N-1))
-            menStd = np.sqrt(y)
-            axHisto.bar(bincenters[y > 0], y[y > 0], width=0, color='r', yerr=stdDev)
-            if(~np.isnan(stdDev) & ~np.isinf(stdDev)):
-                axHisto.set_ylim(0, max(y[y > 0 & ~np.isnan(y) & ~np.isinf(y)] + stdDev))
-            axHisto.set_ylabel("Num. flares")
-            axHisto.set_xlabel("Phase")
-            axHisto.set_title(f"Flare count in phase of {spTyp} type stars with {bins} bins ({numStars} stars)")
-            axHisto.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
-            axHisto.xaxis.set_major_locator(MaxNLocator(5))
-            axHisto.legend()
-
-            axHistoPhase = axHisto.twinx()
-            secAxisXdata = np.linspace(0, 2, num=10000)
-            secAxisYdata = np.cos(secAxisXdata*np.pi) + 1
-            axHistoPhase.plot(secAxisXdata, secAxisYdata)
-            axHistoPhase.set_ylim(0, 7)
-            
-            plt.savefig(f"{locFolder}/{''.join(spTyp)}-Flarecount-{bins}_Bins.png")
-            plt.close()
-
-            for maxY in [1.05, 1.1, 1.2, 1.5, 2, 2.5, 3, 5, max(yData)]:
-                figFlarepeakHist, ((axFlarepeakHist)) = plt.subplots(nrows=1, ncols=1)
-                axFlarepeakHist.set_ylabel("Flare peak")
-                axFlarepeakHist.set_xlabel("Phase")
-                H, xedges, yedges = np.histogram2d(xData, yData, bins=bins, range=[[0, 2], [min(yData), maxY]])
-                cmax = 11
-                H_clipped = np.clip(H, None, cmax)
-                im = axFlarepeakHist.imshow(H_clipped.T, origin='lower', interpolation='nearest',
-                                extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]],
-                                aspect='auto', cmap='viridis')
-                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(f"Flare peak per phase histogram of {spTyp} type stars with {bins} bins ({numStars} stars)")
-                plt.savefig(f"{locFolder}/{''.join(spTyp)}-Flarepeaks-{bins}_Bins_maxY-{maxY}.png")
-                plt.close()
-
-        for maxY in [1.05, 1.1, 1.2, 1.5, 2, 2.5, 3, 5, max(yData)]:
-            figFlarePeaks, ((axFlarePeaks)) = plt.subplots(nrows=1, ncols=1)
-            axFlarePeaks.scatter(pdcsapbinningData[SpTypefilter]["PDCSAPNormPhase"],
-                                 pdcsapbinningData[SpTypefilter]["Peak"],
-                                 label=f"{spTyp} Stars", color=color)
-            axFlarePeaks.set_xlim(0, 2)
-            axFlarePeaks.set_ylim(0.99, maxY)
-            axFlarePeaks.set_ylabel("Flare peak")
-            axFlarePeaks.set_xlabel("Phase")
-            axFlarePeaks.set_title(f"Flare peaks per phase of {spTyp} type stars ({numStars} stars)")
-            axFlarePeaks.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
-            axFlarePeaks.xaxis.set_major_locator(MaxNLocator(5))
-            axFlarePeaks.legend()
-        
-            plt.savefig(f"{locFolder}/{''.join(spTyp)}-Flarepeaks_maxY-{maxY}.png")
-            plt.close()

identify_unknown_sptypes.py

@@ -51,7 +51,7 @@ spTypeTeffMinTable = {2700: "M",
                       7920: "A"}
 
 def getSpTypeFromTeff(Teff):
-    if(Teff >= 30000):
+    if(Teff >= 25000):
         return "O"
     elif(Teff >= 10000):
         return "B"
@@ -59,14 +59,14 @@ def getSpTypeFromTeff(Teff):
         return "A"
     elif(Teff >= 6000):
         return "F"
-    elif(Teff >= 5200):
+    elif(Teff >= 5000):
         return "G"
-    elif(Teff >= 3700):
+    elif(Teff >= 3500):
         return "K"
-    elif(Teff >= 2400):
+    #elif(Teff >= 2700):
-        return "M"
+    #    return "M"
     else:
-        return "L"
+        return "M"
 
 resTable = {"StarID": [],
             "simbad B-V": [],
@@ -177,3 +177,6 @@ for star in allStars:
                              ignore_index=True)
 
 print(resTable.to_string())
+
+for index, row in resTable.iterrows():
+    starDB.updateStarInfoSpType(row["StarID"], row["Final SpType"])

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):
-        self.edPlotFoldPeriod.setText(str(periods[0].value))
+        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)
+        #pdcsapEpochTime = getEpochTime(lc)
-        pdcsapFoldedLC = lc.fold(period=pdcsapPeakPeriod, epoch_time=pdcsapEpochTime)
+        #pdcsapFoldedLC = lc.fold(period=pdcsapPeakPeriod, epoch_time=pdcsapEpochTime)
-        pdcsapPhase, pdcsapSineFit, pdcsapFitType = getFoldedBestFit(pdcsapFoldedLC, fitType=filesDict["FitType"])
+        #pdcsapPhase, pdcsapSineFit, pdcsapFitType = getFoldedBestFit(pdcsapFoldedLC, fitType=filesDict["FitType"])
-        pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit)
+        optimizedFit = getOptimizedFold(lc.normalize(), filesDict["FitType"])
-        pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True)
+        #pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit)
-        pdcsapFoldedPeaks = []
+        #pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True)
-        pdcsapFoldedPeaksPhasePair = []
+        pdcsapFoldedPeaks = []; pdcsapPeriodFoldedPeaks = []
-
+        pdcsapFoldedPeaksPhasePair = []; pdcsapPeriodFoldedPeaksPhasePair = []
-        pdcsapFoldedLC.scatter()
+        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})
+            pdcsapFoldedPeaksPhasePair.append({"Phase": optimizedFit["foldedLC"].phase[optimizedFit["foldedLC"].cycle == cycle][foldedIndex], "Peak": peak})
-            plt.plot(pdcsapFoldedLC.phase[pdcsapFoldedLC.cycle == cycle][foldedIndex].value,
+            plt.plot(optimizedFit["foldedLC"].phase[optimizedFit["foldedLC"].cycle == cycle][foldedIndex].value,
-                     pdcsapFoldedLC.flux[pdcsapFoldedLC.cycle == cycle][foldedIndex], "x", color="red")
+                     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["pdcsapFoldedEpoch"] = optimizedFit["epoch"]
-        #filesDict["pdcsapFoldedPhase"] = sapFoldedLC.phase.value
+        filesDict["pdcsapFoldedCycle"] = optimizedFit["foldedLC"].cycle
-        #filesDict["pdcsapFoldedFitPhase"] = pdcsapPhase
+        filesDict["pdcsapFoldedPhase"] = optimizedFit["foldedLC"].phase.value
-        filesDict["pdcsapFoldedFitPhaseStarEnd"] = (pdcsapFoldedLC.phase.value[0], pdcsapFoldedLC.phase.value[-1])
+        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["pdcsapPeriod"] = optimizedFit["Period"]
-        filesDict["pdcsapPeriodMinima"] = pdcsapMinima
+        filesDict["pdcsapSpotModulation"] = optimizedFit["SpotModulation"]
-        filesDict["pdcsapPeriodMinimaBoundaries"] = pdcsapminPhasesBounds
+        filesDict['FitType'] = optimizedFit["fitType"]
-        filesDict["pdcsapPeriodMaxima"] = pdcsapMaxima
+
-        filesDict["pdcsapPeriodMaximaBoundaries"] = pdcsapmaxPhasesBounds
+        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.btNumMinimaMaxima, 0, 5)
-        self.buttonGridLayout.addWidget(self.btNumMinimaMaximaNorm, 0, 6)
+        #self.buttonGridLayout.addWidget(self.btNumMinimaMaximaNorm, 0, 6)
-        self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaxima, 0, 7)
+        #self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaxima, 0, 7)
-        self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaximaPerMinimaMaxima, 0, 8)
+        #self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaximaPerMinimaMaxima, 0, 8)
-        self.buttonGridLayout.addWidget(self.btShowFlaresBinnedOnPhase, 0, 9)
+        #self.buttonGridLayout.addWidget(self.btShowFlaresBinnedOnPhase, 0, 9)
-        self.buttonGridLayout.addWidget(self.textNumBins, 0, 10)
+        #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',
+        data = self.starFLareDictList
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'pdcsapPeaks',
-                                                    'sapFits',
-                                                    'sapPeaks',
-                                                    'sapPeriod',
-                                                    'sapPeriodMinima',
-                                                    'sapPeriodMinimaBoundaries',
-                                                    'sapPeriodMaxima',
-                                                    'sapPeriodMaximaBoundaries',
-                                                    'pdcsapValidTimespans',
-                                                    'pdcsapPeriod',
-                                                    'pdcsapPeriodMinima',
-                                                    'pdcsapPeriodMinimaBoundaries',
-                                                    'pdcsapPeriodMaxima',
-                                                    'pdcsapPeriodMaximaBoundaries'])
 
         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",
+                            as_index=False).agg(aggDic)
-                                                 "pdcsapPeaksCount": "sum"})
         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',
+        data = self.starFLareDictList
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'pdcsapPeaks',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'sapPeaks',
-                                                    'sapPeriod',
-                                                    'sapPeriodMinima',
-                                                    'sapPeriodMinimaBoundaries',
-                                                    'sapPeriodMaxima',
-                                                    'sapPeriodMaximaBoundaries',
-                                                    'pdcsapValidTimespans',
-                                                    'pdcsapPeriod',
-                                                    'pdcsapPeriodMinima',
-                                                    'pdcsapPeriodMinimaBoundaries',
-                                                    'pdcsapPeriodMaxima',
-                                                    'pdcsapPeriodMaximaBoundaries'])
 
         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",
+                            as_index=False).agg(aggDic)
-                                                 "pdcsapPeaksCount": "sum",
-                                                 "sapValidSeconds": "sum",
-                                                 "pdcsapValidSeconds": "sum"})
         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',
+        data = self.starFLareDictList
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'pdcsapPeaks',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'sapPeaks',
-                                                    'sapPeriodMinima',
-                                                    'sapPeriodMinimaBoundaries',
-                                                    'sapPeriodMaxima',
-                                                    'sapPeriodMaximaBoundaries',
-                                                    'pdcsapValidTimespans',
-                                                    'pdcsapPeriodMinima',
-                                                    'pdcsapPeriodMinimaBoundaries',
-                                                    'pdcsapPeriodMaxima',
-                                                    'pdcsapPeriodMaximaBoundaries',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
 
         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",
+                            as_index=False).agg(aggDic)
-                                                 "pdcsapPeriod": "mean"})
         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',
+        data = self.starFLareDictList
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'pdcsapValidTimespans',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
 
         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,
+                            as_index=False).agg(aggDic)
-                                                 "sapPeriodMaxima": sumArrayLengths,
-                                                 "pdcsapPeriodMinima": sumArrayLengths,
-                                                 "pdcsapPeriodMaxima": sumArrayLengths})
         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',
+        data = self.starFLareDictList
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'pdcsapValidTimespans',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
 
         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,
+                            as_index=False).agg(aggDic)
-                                                 "sapPeriodMaxima": sumArrayLengthsNorm,
-                                                 "pdcsapPeriodMinima": sumArrayLengthsNorm,
-                                                 "pdcsapPeriodMaxima": sumArrayLengthsNorm})
         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',
+        data = self.starFLareDictList
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'pdcsapValidTimespans',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
 
         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',
+        data = self.starFLareDictList
-                                                    'DistanceUnit',
-                                                    'FilePath',
-                                                    'RotVel',
-                                                    'RotVelUnit',
-                                                    'Sequence',
-                                                    'pdcsapFits',
-                                                    'sapFits',
-                                                    'sapValidTimespans',
-                                                    'pdcsapValidTimespans',
-                                                    'sapPeaksCount',
-                                                    'pdcsapPeaksCount',
-                                                    'sapValidSeconds',
-                                                    'pdcsapValidSeconds'])
 
         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",
+                            as_index=False).agg(aggDic)
-                                                 "maximaCountSAP": "sum",
-                                                 "minimasSAP": "sum",
-                                                 "maximasSAP": "sum",
-                                                 "minimaCountPDCSAP": "sum",
-                                                 "maximaCountPDCSAP": "sum",
-                                                 "minimasPDCSAP": "sum",
-                                                 "maximasPDCSAP": "sum"})
         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">
+                        <item row="0" column="1">
-                         <widget class="QLabel" name="label_8">
+                         <widget class="QLabel" name="label_10">
-                          <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>
+                           <string>Enable</string>
                           </property>
                          </widget>
                         </item>
-                        <item row="1" column="0">
+                        <item row="4" column="1">
-                         <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">
                          <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">
+                        <item row="3" column="1">
-                         <widget class="QLabel" name="label_10">
+                         <widget class="QLineEdit" name="edPlotFoldPeriod">
-                          <property name="text">
+                          <property name="sizePolicy">
-                           <string>Enable</string>
+                           <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.fluxType = "pdcsap_flux"
-        self.fluxErrType = "sap_flux_err"
+        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,8 +248,28 @@ class FlaredetectorWidget(QtWidgets.QWidget):
             lc = self.currentFlattenLC
             label += " - flattened"
         if(self.FoldState["Enabled"]):
-            lc = lc.fold(period=self.FoldState["Period"],
+            if(self.FoldState["Optimize"]):
-                         epoch_time=self.FoldState["EpochTime"])
+                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"
         if(self.PeriodogramState["Enabled"]):
             lc = lc.to_periodogram(method=self.PeriodogramState["Method"])
@@ -271,15 +293,19 @@ 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")
-            try:
+            if(self.FoldState["Optimize"]):
-                phase, sineFit, _ = getFoldedBestFit(lc, fitType=self.foldedFitType)
+                self.figureAxis.plot(foldOptimizePhase, foldOptimizeFit, color="red")
-                self.figureAxis.plot(phase, sineFit, color="red")
+
-                print(phase, sineFit)
+            else:
-                minPhasesBoundsIndices, maxPhasesBoundsIndices = getPhaseRangesNearPeak(getFoldedFitPeakValley(sineFit), phase)
+                try:
-                plotPhaseRangesNearPeak((minPhasesBoundsIndices, maxPhasesBoundsIndices), phase, ax=self.figureAxis)
+                    phase, sineFit, _ = getFoldedBestFit(lc, fitType=self.foldedFitType)
-            except Exception as e:
+                    self.figureAxis.plot(phase, sineFit, color="red")
-                print("Failed to get fit")
+                    print(phase, sineFit)
-                print(e)
+                    #minPhasesBoundsIndices, maxPhasesBoundsIndices = getPhaseRangesNearPeak(getFoldedFitPeakValley(sineFit), phase)
+                    #plotPhaseRangesNearPeak((minPhasesBoundsIndices, maxPhasesBoundsIndices), phase, ax=self.figureAxis)
+                except Exception as e:
+                    print("Failed to get fit")
+                    print(e)
         elif(self.PeriodogramState["Enabled"]):
             lc.plot(label=label, ax=self.figureAxis, view=self.PeriodogramState["View"])
             if(self.PeriodogramState["View"] == "period"):

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")
+#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")
+#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")
+#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")
+#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")
+#KeplerA = pd.read_csv("D:/Masterthesis/ressources/akthukair_AFD/Results/A-type-superflares.csv")
 
 #kicBasedSP = []
 #for fullKIC in kicNames["kicName"].values: