diff --git a/main/astrodatagui/AstrodataGUI.py b/main/astrodatagui/AstrodataGUI.py index bf783e6..0b4cdb1 100644 --- a/main/astrodatagui/AstrodataGUI.py +++ b/main/astrodatagui/AstrodataGUI.py @@ -64,6 +64,10 @@ class AstrodataGUI(QtWidgets.QMainWindow): self.flaredetectorPreview.periodsCalculated.connect(self.updatePeriods) self.flaredetectorPreview.epochCalculated.connect(self.updateEpochPeriod) + self.rbLinearFit.toggled.connect(self.rbFoldedPlotTypeChanged) + self.rbSineFit.toggled.connect(self.rbFoldedPlotTypeChanged) + self.rbPolynomialFit.toggled.connect(self.rbFoldedPlotTypeChanged) + self.setupCustomSimbadQueries() self.show() self.loadDB() @@ -109,51 +113,52 @@ class AstrodataGUI(QtWidgets.QMainWindow): if not diag.exec(): return try: - result = self.simbad.query_object(diag.starIdentifier) + results = self.simbad.query_object(diag.starIdentifier) except: self.showErrorMessage("Simbad Error", "Failed to fetcch information from Simbad, aborting...") return + results = results.split(";") + for result in results: + try: + mainName = result["MAIN_ID"][0] + except: + self.showErrorMessage("Main Identifier Error", "Failed to grab main identifier, aborting...") + return - try: - mainName = result["MAIN_ID"][0] - except: - self.showErrorMessage("Main Identifier Error", "Failed to grab main identifier, aborting...") - return + try: + altNames = Simbad.query_objectids(mainName) + except: + self.showErrorMessage("Identifier Error", "Failed to grab all identifiers, aborting...") + return - try: - altNames = Simbad.query_objectids(mainName) - except: - self.showErrorMessage("Identifier Error", "Failed to grab all identifiers, aborting...") - return - - try: - specType = result["SP_TYPE"][0] - if(specType == ""): + try: + specType = result["SP_TYPE"][0] + if(specType == ""): + specType = "-" + except: + print("No spectral type found") specType = "-" - except: - print("No spectral type found") - specType = "-" - rotVel = -1 - rotVelUnit = "" - try: - if(result["RVZ_TYPE"][0] == "v"): - rotVel = result["RV_VALUE"][0] - rotVelUnit = str(result["RV_VALUE"].unit) - except: - print("No radial velocity found") + rotVel = -1 + rotVelUnit = "" + try: + if(result["RVZ_TYPE"][0] == "v"): + rotVel = result["RV_VALUE"][0] + rotVelUnit = str(result["RV_VALUE"].unit) + except: + print("No radial velocity found") - try: - dist = float(result["Distance_distance"][0]) - if(np.isnan(dist)): + try: + dist = float(result["Distance_distance"][0]) + if(np.isnan(dist)): + dist = -1 + distUnit = result["Distance_unit"][0] + except: dist = -1 - distUnit = result["Distance_unit"][0] - except: - dist = -1 - distUnit = "" + distUnit = "" - self.starDB.insertStar(mainName, altNames, diag.productManifest, - specType, rotVel, rotVelUnit, dist, distUnit) + self.starDB.insertStar(mainName, altNames, diag.productManifest, + specType, rotVel, rotVelUnit, dist, distUnit) self.updateStarList() @@ -184,14 +189,41 @@ class AstrodataGUI(QtWidgets.QMainWindow): else: self.lbDistance.setText("-") + def updateStarFoldedFitType(self, foldedFitType): + self.rbLinearFit.blockSignals(True) + self.rbSineFit.blockSignals(True) + self.rbPolynomialFit.blockSignals(True) + if(foldedFitType == "linear"): + self.rbLinearFit.setChecked(True) + self.rbSineFit.setChecked(False) + self.rbPolynomialFit.setChecked(False) + elif(foldedFitType == "sine"): + self.rbLinearFit.setChecked(False) + self.rbSineFit.setChecked(True) + self.rbPolynomialFit.setChecked(False) + elif(foldedFitType == "poly"): + self.rbLinearFit.setChecked(False) + self.rbSineFit.setChecked(False) + self.rbPolynomialFit.setChecked(True) + else: + self.rbLinearFit.setChecked(False) + self.rbSineFit.setChecked(False) + self.rbPolynomialFit.setChecked(False) + self.rbLinearFit.blockSignals(False) + self.rbSineFit.blockSignals(False) + self.rbPolynomialFit.blockSignals(False) + def starSelected(self, item): + self.currentStarMainName = item.text() seqs = self.starDB.getStarSequences(item.text()) infos = self.starDB.getStarInfos(item.text()) altNames = self.starDB.getStarAltNames(item.text()) + self.foldedFitType = self.starDB.getFoldedFitType(item.text()) self.lbMainID.setText(item.text()) self.updateSequenceList(seqs) self.updateStarInfo(infos) self.updateStarAltNames(altNames) + self.updateStarFoldedFitType(self.foldedFitType) def sequenceSelected(self, item): self.gbPlotOptions.setEnabled(True) @@ -202,6 +234,21 @@ class AstrodataGUI(QtWidgets.QMainWindow): seq = seqText[1] filePath = self.starDB.getFilePath(mainName, source, seq) self.flaredetectorPreview.setFitsFile(filePath, mainName) + self.flaredetectorPreview.setFoldedFitType(self.foldedFitType) + + def rbFoldedPlotTypeChanged(self, state): + if(state): + print("Folded fit type changed") + self.foldedFitType = "" + match(self.sender()): + case self.rbLinearFit: + self.foldedFitType = "linear" + case self.rbSineFit: + self.foldedFitType = "sine" + case self.rbPolynomialFit: + self.foldedFitType = "poly" + self.starDB.updateFoldedFitType(self.currentStarMainName, self.foldedFitType) + self.flaredetectorPreview.setFoldedFitType(self.foldedFitType) def updatePeriods(self, periods: list): self.edPlotFoldPeriod.setText(str(periods[0].value)) @@ -378,18 +425,20 @@ class AstrodataGUI(QtWidgets.QMainWindow): "DistanceUnit", "Source", "Sequence", - "FilePath"]) + "FilePath", + "FitType"]) for starName in self.starDB.getAllStars(): sequences = self.starDB.getStarSequences(starName) infos = self.starDB.getStarInfos(starName) + fitType = self.starDB.getFoldedFitType(starName) for sourceSeq in sequences: source = sourceSeq["Source"] seq = sourceSeq["Sequence"] filePath = self.starDB.getFilePath(starName, source, seq) allStarsDictList.loc[len(allStarsDictList.index)] = \ [starName, infos["SpType"], infos["RotVel"], infos["RotVelUnit"], - infos["Distance"], infos["DistanceUnit"], source, seq, filePath] + infos["Distance"], infos["DistanceUnit"], source, seq, filePath, fitType] self.calcAllFlaresThread = CalcAllFlaresThread(allStarsDictList) self.calcAllFlaresThread.finished.connect(self.btCountAllFlaresClickedDone) diff --git a/main/astrodatagui/CalcAllFlaresThread.py b/main/astrodatagui/CalcAllFlaresThread.py index bf5fdee..0e81170 100644 --- a/main/astrodatagui/CalcAllFlaresThread.py +++ b/main/astrodatagui/CalcAllFlaresThread.py @@ -6,76 +6,88 @@ import pandas as pd from ..flaredetector.flaredetector import calculateFlareFitsForLightcurve from ..flaredetector.util import * +import warnings +warnings.filterwarnings("ignore") + def getFlareCount(filesDict): - lc = read(filesDict["FilePath"]) - lc.flux = lc["sap_flux"] - lc.flux_err = lc["sap_flux_err"] - 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) - 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}) + try: + print(f"Starting {filesDict['StarName']}, {filesDict['Sequence']}") + lc = read(filesDict["FilePath"]) + lc.flux = lc["sap_flux"] + lc.flux_err = lc["sap_flux_err"] + 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"] - pdcsapPeaks, pdcsapFits = calculateFlareFitsForLightcurve(lc.flatten()) - pdcsapValSec, pdcsapTds = getTotalValidDataInSeconds(lc, "pdcsap_flux") - pdcsapPeriodogram = lc.to_periodogram() - pdcsapPeakPeriod = pdcsapPeriodogram.period[findMaxIndices(pdcsapPeriodogram, num=4, distance=100, sortByHighest=True)[0]] - pdcsapEpochTime = getEpochTime(lc) - pdcsapFoldedLC = lc.fold(period=pdcsapPeakPeriod, epoch_time=pdcsapEpochTime) - pdcsapPhase, pdcsapSineFit, pdcsapFitType = getFoldedBestFit(pdcsapFoldedLC) - pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit) - pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True) - pdcsapFoldedPeaks = [] - pdcsapFoldedPeaksPhasePair = [] - for peak in sapPeaks: - cycle, foldedIndex = convertStarndardIndexToFoldedIndex(pdcsapFoldedLC, peak["StandardIndex"]) - pdcsapFoldedPeaks.append({"Cycle: ": cycle, "Index": foldedIndex}) - pdcsapFoldedPeaksPhasePair.append({"Phase": pdcsapFoldedLC.phase[pdcsapFoldedLC.cycle == cycle][foldedIndex], "Peak": peak}) + lc.flux = lc["pdcsap_flux"] + lc.flux_err = lc["pdcsap_flux_err"] + pdcsapPeaks, pdcsapFits = calculateFlareFitsForLightcurve(lc.flatten()) + pdcsapValSec, pdcsapTds = getTotalValidDataInSeconds(lc, "pdcsap_flux") + pdcsapPeriodogram = lc.to_periodogram() + pdcsapPeakPeriod = pdcsapPeriodogram.period[findMaxIndices(pdcsapPeriodogram, num=4, distance=100, sortByHighest=True)[0]] + pdcsapEpochTime = getEpochTime(lc) + pdcsapFoldedLC = lc.fold(period=pdcsapPeakPeriod, epoch_time=pdcsapEpochTime) + pdcsapPhase, pdcsapSineFit, pdcsapFitType = getFoldedBestFit(pdcsapFoldedLC, fitType=filesDict["FitType"]) + pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit) + pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True) + pdcsapFoldedPeaks = [] + pdcsapFoldedPeaksPhasePair = [] + for peak in sapPeaks: + cycle, foldedIndex = convertStarndardIndexToFoldedIndex(pdcsapFoldedLC, peak["StandardIndex"]) + pdcsapFoldedPeaks.append({"Cycle: ": cycle, "Index": foldedIndex}) + pdcsapFoldedPeaksPhasePair.append({"Phase": pdcsapFoldedLC.phase[pdcsapFoldedLC.cycle == cycle][foldedIndex], "Peak": peak}) - filesDict["sapPeaks"] = sapPeaks - filesDict["sapPeaksCount"] = len(sapPeaks) - filesDict["sapFits"] = sapFits - filesDict["sapValidTimespans"] = sapTds - filesDict["sapValidSeconds"] = sapValSec - filesDict["sapFoldedCycle"] = sapFoldedLC.cycle - #filesDict["sapFoldedPhase"] = sapFoldedLC.phase.value - #filesDict["sapFoldedFitPhase"] = sapPhase - filesDict["sapFoldedFitPhaseStarEnd"] = (sapFoldedLC.phase.value[0], sapFoldedLC.phase.value[-1]) - filesDict["sapFoldedPeaksPhasePair"] = sapFoldedPeaksPhasePair - filesDict["sapPeriod"] = sapPeakPeriod.value - filesDict["sapPeriodMinima"] = sapMinima - filesDict["sapPeriodMinimaBoundaries"] = sapminPhasesBounds - filesDict["sapPeriodMaxima"] = sapMaxima - filesDict["sapPeriodMaximaBoundaries"] = sapmaxPhasesBounds - filesDict["pdcsapPeaks"] = pdcsapPeaks - filesDict["pdcsapPeaksCount"] = len(pdcsapPeaks) - filesDict["pdcsapFits"] = pdcsapFits - filesDict["pdcsapValidTimespans"] = pdcsapTds - filesDict["pdcsapValidSeconds"] = pdcsapValSec - filesDict["pdcsapFoldedCycle"] = sapFoldedLC.cycle - #filesDict["pdcsapFoldedPhase"] = sapFoldedLC.phase.value - #filesDict["pdcsapFoldedFitPhase"] = pdcsapPhase - filesDict["pdcsapFoldedFitPhaseStarEnd"] = (pdcsapFoldedLC.phase.value[0], pdcsapFoldedLC.phase.value[-1]) - filesDict["pdcsapFoldedPeaksPhasePair"] = pdcsapFoldedPeaksPhasePair - filesDict["pdcsapPeriod"] = pdcsapPeakPeriod.value - filesDict["pdcsapPeriodMinima"] = pdcsapMinima - filesDict["pdcsapPeriodMinimaBoundaries"] = pdcsapminPhasesBounds - filesDict["pdcsapPeriodMaxima"] = pdcsapMaxima - filesDict["pdcsapPeriodMaximaBoundaries"] = pdcsapmaxPhasesBounds - del lc - return filesDict + filesDict["sapPeaks"] = sapPeaks + filesDict["sapPeaksCount"] = len(sapPeaks) + filesDict["sapFits"] = sapFits + filesDict["sapValidTimespans"] = sapTds + filesDict["sapValidSeconds"] = sapValSec + filesDict["sapFoldedCycle"] = sapFoldedLC.cycle + #filesDict["sapFoldedPhase"] = sapFoldedLC.phase.value + #filesDict["sapFoldedFitPhase"] = sapPhase + filesDict["sapFoldedFitPhaseStarEnd"] = (sapFoldedLC.phase.value[0], sapFoldedLC.phase.value[-1]) + filesDict["sapFoldedPeaksPhasePair"] = sapFoldedPeaksPhasePair + filesDict["sapPeriod"] = sapPeakPeriod.value + filesDict["sapPeriodMinima"] = sapMinima + filesDict["sapPeriodMinimaBoundaries"] = sapminPhasesBounds + filesDict["sapPeriodMaxima"] = sapMaxima + filesDict["sapPeriodMaximaBoundaries"] = sapmaxPhasesBounds + filesDict["pdcsapPeaks"] = pdcsapPeaks + filesDict["pdcsapPeaksCount"] = len(pdcsapPeaks) + filesDict["pdcsapFits"] = pdcsapFits + filesDict["pdcsapValidTimespans"] = pdcsapTds + filesDict["pdcsapValidSeconds"] = pdcsapValSec + filesDict["pdcsapFoldedCycle"] = sapFoldedLC.cycle + #filesDict["pdcsapFoldedPhase"] = sapFoldedLC.phase.value + #filesDict["pdcsapFoldedFitPhase"] = pdcsapPhase + filesDict["pdcsapFoldedFitPhaseStarEnd"] = (pdcsapFoldedLC.phase.value[0], pdcsapFoldedLC.phase.value[-1]) + filesDict["pdcsapFoldedPeaksPhasePair"] = pdcsapFoldedPeaksPhasePair + filesDict["pdcsapPeriod"] = pdcsapPeakPeriod.value + filesDict["pdcsapPeriodMinima"] = pdcsapMinima + filesDict["pdcsapPeriodMinimaBoundaries"] = pdcsapminPhasesBounds + filesDict["pdcsapPeriodMaxima"] = pdcsapMaxima + filesDict["pdcsapPeriodMaximaBoundaries"] = pdcsapmaxPhasesBounds + del lc + print(f"Finished {filesDict['StarName']}, {filesDict['Sequence']}") + return filesDict + except Exception as e: + print("------------------------------------------------------------------------") + print(f"Exception in {filesDict['StarName']}, {filesDict['Sequence']}") + print(e) + print("------------------------------------------------------------------------") + return None class CalcAllFlaresThread(QThread): progress = pyqtSignal(int) @@ -89,7 +101,7 @@ class CalcAllFlaresThread(QThread): def run(self): cpuCount = multiprocessing.cpu_count() executor = concurrent.futures.ProcessPoolExecutor(cpuCount) - + #resFrame = pd.DataFrame([getFlareCount(entry) for entry in self.allFlaresDictList.to_dict(orient="records")]) resFrame = pd.DataFrame(executor.map(getFlareCount, self.allFlaresDictList.to_dict(orient="records"))) self.finished.emit(resFrame) \ No newline at end of file diff --git a/main/astrodatagui/FlareSummaryPlotGUI.py b/main/astrodatagui/FlareSummaryPlotGUI.py index e01880d..97e82d7 100644 --- a/main/astrodatagui/FlareSummaryPlotGUI.py +++ b/main/astrodatagui/FlareSummaryPlotGUI.py @@ -9,6 +9,38 @@ import numpy as np import pandas as pd from itertools import compress +def getNumFlaresInbetweenBound(flarePhasesPairs, lowerBound, higherBound): + count = 0 + for flarePhasePair in flarePhasesPairs: + if(flarePhasePair["Phase"] >= lowerBound and + flarePhasePair["Phase"] <= higherBound): + count += 1 + return count + +def getNumFlaresInBounds(flarePhasesPairs, bounds): + count = 0 + #print("bounds", bounds) + if(len(bounds) > 0): + for bound in bounds[0]: + #print("bound", bound) + if(bound[0] < bound[1]): + count += getNumFlaresInbetweenBound(flarePhasesPairs, bound[0], bound[1]) + else: + count += getNumFlaresInbetweenBound(flarePhasesPairs, bound[1], bound[0]) + return count + +def sumArrayLengths(series): + sumRes = 0 + for s in series: + sumRes += len(s) + return sumRes + +def sumArrayLengthsNorm(series): + sumRes = 0 + for s in series: + sumRes += len(s) + return sumRes / len(series) + class FlareSummaryPlotGUI(QWidget): def __init__(self, starFLareDictList): @@ -46,6 +78,15 @@ class FlareSummaryPlotGUI(QWidget): self.btShowPeriods = QPushButton("Show Mean Periods") self.btShowPeriods.clicked.connect(self.btShowPeriodsClicked) + self.btNumMinimaMaxima = QPushButton("Show num Minima/Maxima") + self.btNumMinimaMaxima.clicked.connect(self.btShowNumMinimaMaximaClicked) + self.btNumMinimaMaximaNorm = QPushButton("Show num Minima/Maxima Norm") + self.btNumMinimaMaximaNorm.clicked.connect(self.btShowNumMinimaMaximaNormalizedClicked) + self.btShowFlaresInMinimaMaxima = QPushButton("Show num Flares in Minima/Maxima") + self.btShowFlaresInMinimaMaxima.clicked.connect(self.btShowFlaresInMinimaMaximaClicked) + self.btShowFlaresInMinimaMaximaPerMinimaMaxima = QPushButton("Show num Flares Minima/Maxima normalized") + self.btShowFlaresInMinimaMaximaPerMinimaMaxima.clicked.connect(self.btShowFlaresInMinimaMaximaPerMinimaMaximaClicked) + self.cbKepler = QCheckBox("Kepler") self.cbKepler.setChecked(True) self.cbK2 = QCheckBox("K2") @@ -66,11 +107,20 @@ class FlareSummaryPlotGUI(QWidget): self.cbSpTypeUnknown = QCheckBox("Unknown") self.cbSpTypeUnknown.setChecked(True) + self.cbShowSAP = QCheckBox("SAP") + self.cbShowSAP.setChecked(True) + self.cbShowPDCSAP = QCheckBox("PDCSAP") + self.cbShowPDCSAP.setChecked(True) + self.buttonGridLayout.addWidget(QLabel("Plot Types: "), 0, 0) self.buttonGridLayout.addWidget(self.btShowFlaresPerFile, 0, 1) self.buttonGridLayout.addWidget(self.btShowFlaresPerStar, 0, 2) self.buttonGridLayout.addWidget(self.btShowFlaresPerStarNormalized, 0, 3) self.buttonGridLayout.addWidget(self.btShowPeriods, 0, 4) + self.buttonGridLayout.addWidget(self.btNumMinimaMaxima, 0, 5) + self.buttonGridLayout.addWidget(self.btNumMinimaMaximaNorm, 0, 6) + self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaxima, 0, 7) + self.buttonGridLayout.addWidget(self.btShowFlaresInMinimaMaximaPerMinimaMaxima, 0, 8) self.buttonGridLayout.addWidget(QLabel("Sources: "), 1, 0) self.buttonGridLayout.addWidget(self.cbKepler, 1, 1) @@ -84,6 +134,10 @@ class FlareSummaryPlotGUI(QWidget): self.buttonGridLayout.addWidget(self.cbSpTypeG, 2, 4) self.buttonGridLayout.addWidget(self.cbSpTypeF, 2, 5) self.buttonGridLayout.addWidget(self.cbSpTypeUnknown, 2, 6) + + self.buttonGridLayout.addWidget(self.cbShowSAP, 3, 0) + self.buttonGridLayout.addWidget(self.cbShowPDCSAP, 3, 1) + self.mainLayout.addLayout(self.buttonGridLayout) self.mainLayout.addWidget(toolbar) self.mainLayout.addWidget(fc) @@ -134,28 +188,40 @@ class FlareSummaryPlotGUI(QWidget): self.figureAxis.clear() if(self.cbSpTypeL.isChecked()): if(np.any(Lfilter)): - self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"], marker="o", color="brown", label="L SAP Count") - self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"], marker="x", color="brown", label="L PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"], marker="o", color="brown", label="L SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"], marker="x", color="brown", label="L PDCSAP Count") if(self.cbSpTypeM.isChecked()): if(np.any(Mfilter)): - self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"], marker="o", color="red", label="M SAP Count") - self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"], marker="x", color="red", label="M PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"], marker="o", color="red", label="M SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"], marker="x", color="red", label="M PDCSAP Count") if(self.cbSpTypeK.isChecked()): if(np.any(Kfilter)): - self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"], marker="o", color="orange", label="K SAP Count") - self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"], marker="x", color="orange", label="K PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"], marker="o", color="orange", label="K SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"], marker="x", color="orange", label="K PDCSAP Count") if(self.cbSpTypeG.isChecked()): if(np.any(Gfilter)): - self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"], marker="o", color="yellow", label="G SAP Count") - self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"], marker="x", color="yellow", label="G PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"], marker="o", color="yellow", label="G SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"], marker="x", color="yellow", label="G PDCSAP Count") if(self.cbSpTypeF.isChecked()): if(np.any(Ffilter)): - self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"], marker="o", color="greenyellow", label="F SAP Count") - self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"], marker="x", color="greenyellow", label="F PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"], marker="o", color="greenyellow", label="F SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"], marker="x", color="greenyellow", label="F PDCSAP Count") if(self.cbSpTypeUnknown.isChecked()): if(np.any(Unknownfilter)): - self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"], marker="o", color="gray", label="Unknown SAP Count") - self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"], marker="x", color="gray", label="Unknown PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"], marker="o", color="gray", label="Unknown SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"], marker="x", color="gray", label="Unknown PDCSAP Count") self.figureAxis.set_ylabel("Flare count") self.figureAxis.set_xlabel("File Number") @@ -224,28 +290,40 @@ class FlareSummaryPlotGUI(QWidget): self.figureAxis.clear() if(self.cbSpTypeL.isChecked()): if(np.any(Lfilter)): - self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"], marker="o", color="brown", label="L SAP Count") - self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"], marker="x", color="brown", label="L PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"], marker="o", color="brown", label="L SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"], marker="x", color="brown", label="L PDCSAP Count") if(self.cbSpTypeM.isChecked()): if(np.any(Mfilter)): - self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"], marker="o", color="red", label="M SAP Count") - self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"], marker="x", color="red", label="M PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"], marker="o", color="red", label="M SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"], marker="x", color="red", label="M PDCSAP Count") if(self.cbSpTypeK.isChecked()): if(np.any(Kfilter)): - self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"], marker="o", color="orange", label="K SAP Count") - self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"], marker="x", color="orange", label="K PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"], marker="o", color="orange", label="K SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"], marker="x", color="orange", label="K PDCSAP Count") if(self.cbSpTypeG.isChecked()): if(np.any(Gfilter)): - self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"], marker="o", color="yellow", label="G SAP Count") - self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"], marker="x", color="yellow", label="G PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"], marker="o", color="yellow", label="G SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"], marker="x", color="yellow", label="G PDCSAP Count") if(self.cbSpTypeF.isChecked()): if(np.any(Ffilter)): - self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"], marker="o", color="greenyellow", label="F SAP Count") - self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"], marker="x", color="greenyellow", label="F PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"], marker="o", color="greenyellow", label="F SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"], marker="x", color="greenyellow", label="F PDCSAP Count") if(self.cbSpTypeUnknown.isChecked()): if(np.any(Unknownfilter)): - self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"], marker="o", color="gray", label="Unknown SAP Count") - self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"], marker="x", color="gray", label="Unknown PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"], marker="o", color="gray", label="Unknown SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"], marker="x", color="gray", label="Unknown PDCSAP Count") self.figureAxis.set_ylabel("Flare count") self.figureAxis.set_xlabel("Star Number") @@ -317,40 +395,52 @@ class FlareSummaryPlotGUI(QWidget): self.figureAxis.clear() if(self.cbSpTypeL.isChecked()): if(np.any(Lfilter)): - self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"]/(data[Lfilter]["sapValidSeconds"]/60/60/24/7), - marker="o", color="brown", label="L SAP Count") - self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"]/(data[Lfilter]["pdcsapValidSeconds"]/60/60/24/7), - marker="x", color="brown", label="L PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"]/(data[Lfilter]["sapValidSeconds"]/60/60/24/7), + marker="o", color="brown", label="L SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"]/(data[Lfilter]["pdcsapValidSeconds"]/60/60/24/7), + marker="x", color="brown", label="L PDCSAP Count") if(self.cbSpTypeM.isChecked()): if(np.any(Mfilter)): - self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"]/(data[Mfilter]["sapValidSeconds"]/60/60/24/7), - marker="o", color="red", label="M SAP Count") - self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"]/(data[Mfilter]["pdcsapValidSeconds"]/60/60/24/7), - marker="x", color="red", label="M PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"]/(data[Mfilter]["sapValidSeconds"]/60/60/24/7), + marker="o", color="red", label="M SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"]/(data[Mfilter]["pdcsapValidSeconds"]/60/60/24/7), + marker="x", color="red", label="M PDCSAP Count") if(self.cbSpTypeK.isChecked()): if(np.any(Kfilter)): - self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"]/(data[Kfilter]["sapValidSeconds"]/60/60/24/7), - marker="o", color="orange", label="K SAP Count") - self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"]/(data[Kfilter]["pdcsapValidSeconds"]/60/60/24/7), - marker="x", color="orange", label="K PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"]/(data[Kfilter]["sapValidSeconds"]/60/60/24/7), + marker="o", color="orange", label="K SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"]/(data[Kfilter]["pdcsapValidSeconds"]/60/60/24/7), + marker="x", color="orange", label="K PDCSAP Count") if(self.cbSpTypeG.isChecked()): if(np.any(Gfilter)): - self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"]/(data[Gfilter]["sapValidSeconds"]/60/60/24/7), - marker="o", color="yellow", label="G SAP Count") - self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"]/(data[Gfilter]["pdcsapValidSeconds"]/60/60/24/7), - marker="x", color="yellow", label="G PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"]/(data[Gfilter]["sapValidSeconds"]/60/60/24/7), + marker="o", color="yellow", label="G SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"]/(data[Gfilter]["pdcsapValidSeconds"]/60/60/24/7), + marker="x", color="yellow", label="G PDCSAP Count") if(self.cbSpTypeF.isChecked()): if(np.any(Ffilter)): - self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"]/(data[Ffilter]["sapValidSeconds"]/60/60/24/7), - marker="o", color="greenyellow", label="F SAP Count") - self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"]/(data[Ffilter]["pdcsapValidSeconds"]/60/60/24/7), - marker="x", color="greenyellow", label="F PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"]/(data[Ffilter]["sapValidSeconds"]/60/60/24/7), + marker="o", color="greenyellow", label="F SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"]/(data[Ffilter]["pdcsapValidSeconds"]/60/60/24/7), + marker="x", color="greenyellow", label="F PDCSAP Count") if(self.cbSpTypeUnknown.isChecked()): if(np.any(Unknownfilter)): - self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"]/(data[Unknownfilter]["sapValidSeconds"]/60/60/24/7), - marker="o", color="gray", label="Unknown SAP Count") - self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"]/(data[Unknownfilter]["pdcsapValidSeconds"]/60/60/24/7), - marker="x", color="gray", label="Unknown PDCSAP Count") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"]/(data[Unknownfilter]["sapValidSeconds"]/60/60/24/7), + marker="o", color="gray", label="Unknown SAP Count") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"]/(data[Unknownfilter]["pdcsapValidSeconds"]/60/60/24/7), + marker="x", color="gray", label="Unknown PDCSAP Count") self.figureAxis.set_ylabel("Flare count per Week") self.figureAxis.set_xlabel("Star Number") @@ -424,40 +514,52 @@ class FlareSummaryPlotGUI(QWidget): self.figureAxis.clear() if(self.cbSpTypeL.isChecked()): if(np.any(Lfilter)): - self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeriod"], - marker="o", color="brown", label="L SAP Period") - self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeriod"], - marker="x", color="brown", label="L PDCSAP Period") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeriod"], + marker="o", color="brown", label="L SAP Period") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeriod"], + marker="x", color="brown", label="L PDCSAP Period") if(self.cbSpTypeM.isChecked()): if(np.any(Mfilter)): - self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeriod"], - marker="o", color="red", label="M SAP Period") - self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeriod"], - marker="x", color="red", label="M PDCSAP Period") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeriod"], + marker="o", color="red", label="M SAP Period") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeriod"], + marker="x", color="red", label="M PDCSAP Period") if(self.cbSpTypeK.isChecked()): if(np.any(Kfilter)): - self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeriod"], - marker="o", color="orange", label="K SAP Period") - self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeriod"], - marker="x", color="orange", label="K PDCSAP Period") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeriod"], + marker="o", color="orange", label="K SAP Period") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeriod"], + marker="x", color="orange", label="K PDCSAP Period") if(self.cbSpTypeG.isChecked()): if(np.any(Gfilter)): - self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeriod"], - marker="o", color="yellow", label="G SAP Period") - self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeriod"], - marker="x", color="yellow", label="G PDCSAP Period") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeriod"], + marker="o", color="yellow", label="G SAP Period") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeriod"], + marker="x", color="yellow", label="G PDCSAP Period") if(self.cbSpTypeF.isChecked()): if(np.any(Ffilter)): - self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeriod"], - marker="o", color="greenyellow", label="F SAP Period") - self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeriod"], - marker="x", color="greenyellow", label="F PDCSAP Period") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeriod"], + marker="o", color="greenyellow", label="F SAP Period") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeriod"], + marker="x", color="greenyellow", label="F PDCSAP Period") if(self.cbSpTypeUnknown.isChecked()): if(np.any(Unknownfilter)): - self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeriod"], - marker="o", color="gray", label="Unknown SAP Period") - self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeriod"], - marker="x", color="gray", label="Unknown PDCSAP Period") + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeriod"], + marker="o", color="gray", label="Unknown SAP Period") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeriod"], + marker="x", color="gray", label="Unknown PDCSAP Period") self.figureAxis.set_ylabel("Period / days") self.figureAxis.set_xlabel("Star Number") @@ -466,10 +568,730 @@ class FlareSummaryPlotGUI(QWidget): pass def btShowNumMinimaMaximaClicked(self): + data = self.starFLareDictList.drop(columns=['Distance', + 'DistanceUnit', + 'FilePath', + 'RotVel', + 'RotVelUnit', + 'Sequence', + 'pdcsapFits', + 'sapFits', + 'sapValidTimespans', + 'pdcsapValidTimespans', + 'sapPeaksCount', + 'pdcsapPeaksCount', + 'sapValidSeconds', + 'pdcsapValidSeconds']) + + showSourceFilter = np.full(len(data), False) + + if(self.cbKepler.isChecked()): + showKepler = data["Source"] == "Kepler" + showSourceFilter |= showKepler + if(self.cbK2.isChecked()): + showK2 = data["Source"] == "K2" + showSourceFilter |= showK2 + if(self.cbTESS.isChecked()): + showTESS = data["Source"] == "TESS" + showSourceFilter |= showTESS + + print(data["sapPeriod"]) + + data = data[showSourceFilter].groupby(["StarName", "SpType"], + as_index=False).agg({"sapPeriodMinima": sumArrayLengths, + "sapPeriodMaxima": sumArrayLengths, + "pdcsapPeriodMinima": sumArrayLengths, + "pdcsapPeriodMaxima": sumArrayLengths}) + x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int) + + if(self.cbSpTypeL.isChecked()): + Lfilter = data["SpType"].str.startswith("L") + Lfilter &= showSourceFilter + if(self.cbSpTypeM.isChecked()): + Mfilter = data["SpType"].str.startswith("M") + Mfilter &= showSourceFilter + if(self.cbSpTypeK.isChecked()): + Kfilter = data["SpType"].str.startswith("K") + Kfilter &= showSourceFilter + if(self.cbSpTypeG.isChecked()): + Gfilter = data["SpType"].str.startswith("G") + Gfilter &= showSourceFilter + if(self.cbSpTypeF.isChecked()): + Ffilter = data["SpType"].str.startswith("F") + Ffilter &= showSourceFilter + if(self.cbSpTypeUnknown.isChecked()): + Unknownfilter = data["SpType"].str.startswith("-") + Unknownfilter &= showSourceFilter + + self.figureAxis.clear() + if(self.cbSpTypeL.isChecked()): + if(np.any(Lfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeriodMinima"], + marker="v", color="brown", label="L SAP Minima") + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeriodMaxima"], + marker="^", color="brown", label="L SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeriodMinima"], + marker="<", color="brown", label="L PDCSAP Minima") + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeriodMaxima"], + marker=">", color="brown", label="L PDCSAP Maxima") + if(self.cbSpTypeM.isChecked()): + if(np.any(Mfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeriodMinima"], + marker="v", color="red", label="M SAP Minima") + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeriodMaxima"], + marker="^", color="red", label="M SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeriodMinima"], + marker="<", color="red", label="M PDCSAP Minima") + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeriodMaxima"], + marker=">", color="red", label="M PDCSAP Maxima") + if(self.cbSpTypeK.isChecked()): + if(np.any(Kfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeriodMinima"], + marker="v", color="orange", label="K SAP Minima") + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeriodMaxima"], + marker="^", color="orange", label="K SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeriodMinima"], + marker="<", color="orange", label="K PDCSAP Minima") + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeriodMaxima"], + marker=">", color="orange", label="K PDCSAP Maxima") + if(self.cbSpTypeG.isChecked()): + if(np.any(Gfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeriodMinima"], + marker="v", color="yellow", label="G SAP Minima") + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeriodMaxima"], + marker="^", color="yellow", label="G SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeriodMinima"], + marker="<", color="yellow", label="G PDCSAP Minima") + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeriodMaxima"], + marker=">", color="yellow", label="G PDCSAP Maxima") + if(self.cbSpTypeF.isChecked()): + if(np.any(Ffilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeriodMinima"], + marker="v", color="greenyellow", label="F SAP Minima") + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeriodMaxima"], + marker="^", color="greenyellow", label="F SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeriodMinima"], + marker="<", color="greenyellow", label="F PDCSAP Minima") + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeriodMaxima"], + marker=">", color="greenyellow", label="F PDCSAP Maxima") + if(self.cbSpTypeUnknown.isChecked()): + if(np.any(Unknownfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeriodMinima"], + marker="v", color="gray", label="Unknown SAP Minima") + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeriodMaxima"], + marker="^", color="gray", label="Unknown SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeriodMinima"], + marker="<", color="gray", label="Unknown PDCSAP Minima") + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeriodMaxima"], + marker=">", color="gray", label="Unknown PDCSAP Maxima") + + self.figureAxis.set_ylabel("Amount") + self.figureAxis.set_xlabel("Star Number") + self.figureAxis.legend() + self.figure.canvas.draw_idle() + pass + + def btShowNumMinimaMaximaNormalizedClicked(self): + data = self.starFLareDictList.drop(columns=['Distance', + 'DistanceUnit', + 'FilePath', + 'RotVel', + 'RotVelUnit', + 'Sequence', + 'pdcsapFits', + 'sapFits', + 'sapValidTimespans', + 'pdcsapValidTimespans', + 'sapPeaksCount', + 'pdcsapPeaksCount', + 'sapValidSeconds', + 'pdcsapValidSeconds']) + + showSourceFilter = np.full(len(data), False) + + if(self.cbKepler.isChecked()): + showKepler = data["Source"] == "Kepler" + showSourceFilter |= showKepler + if(self.cbK2.isChecked()): + showK2 = data["Source"] == "K2" + showSourceFilter |= showK2 + if(self.cbTESS.isChecked()): + showTESS = data["Source"] == "TESS" + showSourceFilter |= showTESS + + print(data["sapPeriod"]) + + data = data[showSourceFilter].groupby(["StarName", "SpType"], + as_index=False).agg({"sapPeriodMinima": sumArrayLengthsNorm, + "sapPeriodMaxima": sumArrayLengthsNorm, + "pdcsapPeriodMinima": sumArrayLengthsNorm, + "pdcsapPeriodMaxima": sumArrayLengthsNorm}) + x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int) + + if(self.cbSpTypeL.isChecked()): + Lfilter = data["SpType"].str.startswith("L") + Lfilter &= showSourceFilter + if(self.cbSpTypeM.isChecked()): + Mfilter = data["SpType"].str.startswith("M") + Mfilter &= showSourceFilter + if(self.cbSpTypeK.isChecked()): + Kfilter = data["SpType"].str.startswith("K") + Kfilter &= showSourceFilter + if(self.cbSpTypeG.isChecked()): + Gfilter = data["SpType"].str.startswith("G") + Gfilter &= showSourceFilter + if(self.cbSpTypeF.isChecked()): + Ffilter = data["SpType"].str.startswith("F") + Ffilter &= showSourceFilter + if(self.cbSpTypeUnknown.isChecked()): + Unknownfilter = data["SpType"].str.startswith("-") + Unknownfilter &= showSourceFilter + + self.figureAxis.clear() + if(self.cbSpTypeL.isChecked()): + if(np.any(Lfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeriodMinima"], + marker="v", color="brown", label="L SAP Minima") + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeriodMaxima"], + marker="^", color="brown", label="L SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeriodMinima"], + marker="<", color="brown", label="L PDCSAP Minima") + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeriodMaxima"], + marker=">", color="brown", label="L PDCSAP Maxima") + if(self.cbSpTypeM.isChecked()): + if(np.any(Mfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeriodMinima"], + marker="v", color="red", label="M SAP Minima") + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeriodMaxima"], + marker="^", color="red", label="M SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeriodMinima"], + marker="<", color="red", label="M PDCSAP Minima") + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeriodMaxima"], + marker=">", color="red", label="M PDCSAP Maxima") + if(self.cbSpTypeK.isChecked()): + if(np.any(Kfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeriodMinima"], + marker="v", color="orange", label="K SAP Minima") + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeriodMaxima"], + marker="^", color="orange", label="K SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeriodMinima"], + marker="<", color="orange", label="K PDCSAP Minima") + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeriodMaxima"], + marker=">", color="orange", label="K PDCSAP Maxima") + if(self.cbSpTypeG.isChecked()): + if(np.any(Gfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeriodMinima"], + marker="v", color="yellow", label="G SAP Minima") + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeriodMaxima"], + marker="^", color="yellow", label="G SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeriodMinima"], + marker="<", color="yellow", label="G PDCSAP Minima") + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeriodMaxima"], + marker=">", color="yellow", label="G PDCSAP Maxima") + if(self.cbSpTypeF.isChecked()): + if(np.any(Ffilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeriodMinima"], + marker="v", color="greenyellow", label="F SAP Minima") + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeriodMaxima"], + marker="^", color="greenyellow", label="F SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeriodMinima"], + marker="<", color="greenyellow", label="F PDCSAP Minima") + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeriodMaxima"], + marker=">", color="greenyellow", label="F PDCSAP Maxima") + if(self.cbSpTypeUnknown.isChecked()): + if(np.any(Unknownfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeriodMinima"], + marker="v", color="gray", label="Unknown SAP Minima") + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeriodMaxima"], + marker="^", color="gray", label="Unknown SAP Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeriodMinima"], + marker="<", color="gray", label="Unknown PDCSAP Minima") + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeriodMaxima"], + marker=">", color="gray", label="Unknown PDCSAP Maxima") + + self.figureAxis.set_ylabel("Amount") + self.figureAxis.set_xlabel("Star Number") + self.figureAxis.legend() + self.figure.canvas.draw_idle() pass def btShowFlaresInMinimaMaximaClicked(self): + data = self.starFLareDictList.drop(columns=['Distance', + 'DistanceUnit', + 'FilePath', + 'RotVel', + 'RotVelUnit', + 'Sequence', + 'pdcsapFits', + 'sapFits', + 'sapValidTimespans', + 'pdcsapValidTimespans', + 'sapPeaksCount', + 'pdcsapPeaksCount', + 'sapValidSeconds', + 'pdcsapValidSeconds']) + + showSourceFilter = np.full(len(data), False) + + if(self.cbKepler.isChecked()): + showKepler = data["Source"] == "Kepler" + showSourceFilter |= showKepler + if(self.cbK2.isChecked()): + showK2 = data["Source"] == "K2" + showSourceFilter |= showK2 + if(self.cbTESS.isChecked()): + showTESS = data["Source"] == "TESS" + showSourceFilter |= showTESS + + print(data["sapPeriod"]) + + finalData = [] + #data = data[showSourceFilter].groupby(["StarName", "SpType"], + # as_index=False).agg({"sapPeriod": "mean", + # "pdcsapPeriod": "mean"}) + for ind, row in data[showSourceFilter].reset_index().iterrows(): + print("sapPeriodMinimaBoundaries", row["sapPeriodMinimaBoundaries"]) + print("sapPeriodMaximaBoundaries", row["sapPeriodMaximaBoundaries"]) + print("pdcsapPeriodMinimaBoundaries", row["pdcsapPeriodMinimaBoundaries"]) + print("pdcsapPeriodMaximaBoundaries", row["pdcsapPeriodMaximaBoundaries"]) + minimaCountSAP = getNumFlaresInBounds(row["sapFoldedPeaksPhasePair"], + row["sapPeriodMinimaBoundaries"]) + minimaCountPDCSAP = getNumFlaresInBounds(row["pdcsapFoldedPeaksPhasePair"], + row["pdcsapPeriodMinimaBoundaries"]) + maximaCountSAP = getNumFlaresInBounds(row["sapFoldedPeaksPhasePair"], + row["sapPeriodMaximaBoundaries"]) + maximaCountPDCSAP = getNumFlaresInBounds(row["pdcsapFoldedPeaksPhasePair"], + row["pdcsapPeriodMaximaBoundaries"]) + finalData.append({"SpType": row["SpType"], "StarName": row["StarName"], + "minimaCountSAP": minimaCountSAP, "maximaCountSAP": maximaCountSAP, + "minimaCountPDCSAP": minimaCountPDCSAP, "maximaCountPDCSAP": maximaCountPDCSAP}) + + data = pd.DataFrame(finalData).groupby(["StarName", "SpType"], + as_index=False).agg({"minimaCountSAP": "sum", + "maximaCountSAP": "sum", + "minimaCountPDCSAP": "sum", + "maximaCountPDCSAP": "sum"}) + x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int) + + if(self.cbSpTypeL.isChecked()): + Lfilter = data["SpType"].str.startswith("L") + Lfilter &= showSourceFilter + if(self.cbSpTypeM.isChecked()): + Mfilter = data["SpType"].str.startswith("M") + Mfilter &= showSourceFilter + if(self.cbSpTypeK.isChecked()): + Kfilter = data["SpType"].str.startswith("K") + Kfilter &= showSourceFilter + if(self.cbSpTypeG.isChecked()): + Gfilter = data["SpType"].str.startswith("G") + Gfilter &= showSourceFilter + if(self.cbSpTypeF.isChecked()): + Ffilter = data["SpType"].str.startswith("F") + Ffilter &= showSourceFilter + if(self.cbSpTypeUnknown.isChecked()): + Unknownfilter = data["SpType"].str.startswith("-") + Unknownfilter &= showSourceFilter + + self.figureAxis.clear() + if(self.cbSpTypeL.isChecked()): + if(np.any(Lfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["minimaCountSAP"], + marker="v", color="brown", label="L SAP in Minima") + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["maximaCountSAP"], + marker="^", color="brown", label="L SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["minimaCountPDCSAP"], + marker="<", color="brown", label="L PDCSAP in Minima") + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["maximaCountPDCSAP"], + marker=">", color="brown", label="L PDCSAP in Maxima") + if(self.cbSpTypeM.isChecked()): + if(np.any(Mfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["minimaCountSAP"], + marker="v", color="red", label="M SAP in Minima") + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["maximaCountSAP"], + marker="^", color="red", label="M SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["minimaCountPDCSAP"], + marker="<", color="red", label="M PDCSAP in Minima") + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["maximaCountPDCSAP"], + marker=">", color="red", label="M PDCSAP in Maxima") + if(self.cbSpTypeK.isChecked()): + if(np.any(Kfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["minimaCountSAP"], + marker="v", color="orange", label="K SAP in Minima") + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["maximaCountSAP"], + marker="^", color="orange", label="K SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["minimaCountPDCSAP"], + marker="<", color="orange", label="K PDCSAP in Minima") + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["maximaCountPDCSAP"], + marker=">", color="orange", label="K PDCSAP in Maxima") + if(self.cbSpTypeG.isChecked()): + if(np.any(Gfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["minimaCountSAP"], + marker="v", color="yellow", label="G SAP in Minima") + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["maximaCountSAP"], + marker="^", color="yellow", label="G SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["minimaCountPDCSAP"], + marker="<", color="yellow", label="G PDCSAP in Minima") + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["maximaCountPDCSAP"], + marker=">", color="yellow", label="G PDCSAP in Maxima") + if(self.cbSpTypeF.isChecked()): + if(np.any(Ffilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["minimaCountSAP"], + marker="v", color="greenyellow", label="F SAP in Minima") + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["maximaCountSAP"], + marker="^", color="greenyellow", label="F SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["minimaCountPDCSAP"], + marker="<", color="greenyellow", label="F PDCSAP in Minima") + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["maximaCountPDCSAP"], + marker=">", color="greenyellow", label="F PDCSAP in Maxima") + if(self.cbSpTypeUnknown.isChecked()): + if(np.any(Unknownfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["minimaCountSAP"], + marker="v", color="gray", label="Unknown SAP in Minima") + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["maximaCountSAP"], + marker="^", color="gray", label="Unknown SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["minimaCountPDCSAP"], + marker="<", color="gray", label="Unknown PDCSAP in Minima") + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["maximaCountPDCSAP"], + marker=">", color="gray", label="Unknown PDCSAP in Maxima") + + self.figureAxis.set_ylabel("Flares in Minima/Maxima") + self.figureAxis.set_xlabel("Star Number") + self.figureAxis.legend() + self.figure.canvas.draw_idle() pass def btShowFlaresInMinimaMaximaPerMinimaMaximaClicked(self): - pass + data = self.starFLareDictList.drop(columns=['Distance', + 'DistanceUnit', + 'FilePath', + 'RotVel', + 'RotVelUnit', + 'Sequence', + 'pdcsapFits', + 'sapFits', + 'sapValidTimespans', + 'pdcsapValidTimespans', + 'sapPeaksCount', + 'pdcsapPeaksCount', + 'sapValidSeconds', + 'pdcsapValidSeconds']) + + showSourceFilter = np.full(len(data), False) + + if(self.cbKepler.isChecked()): + showKepler = data["Source"] == "Kepler" + showSourceFilter |= showKepler + if(self.cbK2.isChecked()): + showK2 = data["Source"] == "K2" + showSourceFilter |= showK2 + if(self.cbTESS.isChecked()): + showTESS = data["Source"] == "TESS" + showSourceFilter |= showTESS + + print(data["sapPeriod"]) + + finalData = [] + for ind, row in data[showSourceFilter].reset_index().iterrows(): + minimaCountSAP = getNumFlaresInBounds(row["sapFoldedPeaksPhasePair"], + row["sapPeriodMinimaBoundaries"]) + minimaCountPDCSAP = getNumFlaresInBounds(row["pdcsapFoldedPeaksPhasePair"], + row["pdcsapPeriodMinimaBoundaries"]) + maximaCountSAP = getNumFlaresInBounds(row["sapFoldedPeaksPhasePair"], + row["sapPeriodMaximaBoundaries"]) + maximaCountPDCSAP = getNumFlaresInBounds(row["pdcsapFoldedPeaksPhasePair"], + row["pdcsapPeriodMaximaBoundaries"]) + finalData.append({"SpType": row["SpType"], "StarName": row["StarName"], + "minimaCountSAP": minimaCountSAP, "maximaCountSAP": maximaCountSAP, + "minimasSAP": len(row["sapPeriodMinima"]), "maximasSAP": len(row["sapPeriodMaxima"]), + "minimaCountPDCSAP": minimaCountPDCSAP, "maximaCountPDCSAP": maximaCountPDCSAP, + "minimasPDCSAP": len(row["pdcsapPeriodMinima"]), "maximasPDCSAP": len(row["pdcsapPeriodMaxima"])}) + + data = pd.DataFrame(finalData).groupby(["StarName", "SpType"], + as_index=False).agg({"minimaCountSAP": "sum", + "maximaCountSAP": "sum", + "minimasSAP": "sum", + "maximasSAP": "sum", + "minimaCountPDCSAP": "sum", + "maximaCountPDCSAP": "sum", + "minimasPDCSAP": "sum", + "maximasPDCSAP": "sum"}) + x = np.arange(start=1, stop=len(data)+1, step=1, dtype=int) + + if(self.cbSpTypeL.isChecked()): + Lfilter = data["SpType"].str.startswith("L") + Lfilter &= showSourceFilter + if(self.cbSpTypeM.isChecked()): + Mfilter = data["SpType"].str.startswith("M") + Mfilter &= showSourceFilter + if(self.cbSpTypeK.isChecked()): + Kfilter = data["SpType"].str.startswith("K") + Kfilter &= showSourceFilter + if(self.cbSpTypeG.isChecked()): + Gfilter = data["SpType"].str.startswith("G") + Gfilter &= showSourceFilter + if(self.cbSpTypeF.isChecked()): + Ffilter = data["SpType"].str.startswith("F") + Ffilter &= showSourceFilter + if(self.cbSpTypeUnknown.isChecked()): + Unknownfilter = data["SpType"].str.startswith("-") + Unknownfilter &= showSourceFilter + + self.figureAxis.clear() + if(self.cbSpTypeL.isChecked()): + if(np.any(Lfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["minimaCountSAP"]/data[Lfilter]["minimasSAP"], + marker="v", color="brown", label="L SAP in Minima") + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["maximaCountSAP"]/data[Lfilter]["maximasSAP"], + marker="^", color="brown", label="L SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["minimaCountPDCSAP"]/data[Lfilter]["minimasPDCSAP"], + marker="<", color="brown", label="L PDCSAP in Minima") + self.figureAxis.scatter(x[Lfilter], data[Lfilter]["maximaCountPDCSAP"]/data[Lfilter]["maximasPDCSAP"], + marker=">", color="brown", label="L PDCSAP in Maxima") + if(self.cbSpTypeM.isChecked()): + if(np.any(Mfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["minimaCountSAP"]/data[Mfilter]["minimasSAP"], + marker="v", color="red", label="M SAP in Minima") + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["maximaCountSAP"]/data[Mfilter]["maximasSAP"], + marker="^", color="red", label="M SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["minimaCountPDCSAP"]/data[Mfilter]["minimasPDCSAP"], + marker="<", color="red", label="M PDCSAP in Minima") + self.figureAxis.scatter(x[Mfilter], data[Mfilter]["maximaCountPDCSAP"]/data[Mfilter]["maximasPDCSAP"], + marker=">", color="red", label="M PDCSAP in Maxima") + if(self.cbSpTypeK.isChecked()): + if(np.any(Kfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["minimaCountSAP"]/data[Kfilter]["minimasSAP"], + marker="v", color="orange", label="K SAP in Minima") + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["maximaCountSAP"]/data[Kfilter]["maximasSAP"], + marker="^", color="orange", label="K SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["minimaCountPDCSAP"]/data[Kfilter]["minimasPDCSAP"], + marker="<", color="orange", label="K PDCSAP in Minima") + self.figureAxis.scatter(x[Kfilter], data[Kfilter]["maximaCountPDCSAP"]/data[Kfilter]["maximasPDCSAP"], + marker=">", color="orange", label="K PDCSAP in Maxima") + if(self.cbSpTypeG.isChecked()): + if(np.any(Gfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["minimaCountSAP"]/data[Gfilter]["minimasSAP"], + marker="v", color="yellow", label="G SAP in Minima") + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["maximaCountSAP"]/data[Gfilter]["maximasSAP"], + marker="^", color="yellow", label="G SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["minimaCountPDCSAP"]/data[Gfilter]["minimasPDCSAP"], + marker="<", color="yellow", label="G PDCSAP in Minima") + self.figureAxis.scatter(x[Gfilter], data[Gfilter]["maximaCountPDCSAP"]/data[Gfilter]["maximasPDCSAP"], + marker=">", color="yellow", label="G PDCSAP in Maxima") + if(self.cbSpTypeF.isChecked()): + if(np.any(Ffilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["minimaCountSAP"]/data[Ffilter]["minimasSAP"], + marker="v", color="greenyellow", label="F SAP in Minima") + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["maximaCountSAP"]/data[Ffilter]["maximasSAP"], + marker="^", color="greenyellow", label="F SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["minimaCountPDCSAP"]/data[Ffilter]["minimasPDCSAP"], + marker="<", color="greenyellow", label="F PDCSAP in Minima") + self.figureAxis.scatter(x[Ffilter], data[Ffilter]["maximaCountPDCSAP"]/data[Ffilter]["maximasPDCSAP"], + marker=">", color="greenyellow", label="F PDCSAP in Maxima") + if(self.cbSpTypeUnknown.isChecked()): + if(np.any(Unknownfilter)): + if(self.cbShowSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["minimaCountSAP"]/data[Unknownfilter]["minimasSAP"], + marker="v", color="gray", label="Unknown SAP in Minima") + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["maximaCountSAP"]/data[Unknownfilter]["maximasSAP"], + marker="^", color="gray", label="Unknown SAP in Maxima") + if(self.cbShowPDCSAP.isChecked()): + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["minimaCountPDCSAP"]/data[Unknownfilter]["minimasPDCSAP"], + marker="<", color="gray", label="Unknown PDCSAP in Minima") + self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["maximaCountPDCSAP"]/data[Unknownfilter]["maximasPDCSAP"], + marker=">", color="gray", label="Unknown PDCSAP in Maxima") + + self.figureAxis.set_ylabel("Avg. flares per minima/maxima") + self.figureAxis.set_xlabel("Star Number") + self.figureAxis.legend() + self.figure.canvas.draw_idle() + + # SAP + SAP_L_stars_minima_data = np.array(data[Lfilter]["minimaCountSAP"]/data[Lfilter]["minimasSAP"]) + SAP_L_stars_maxima_data = np.array(data[Lfilter]["maximaCountSAP"]/data[Lfilter]["maximasSAP"]) + + SAP_M_stars_minima_data = np.array(data[Mfilter]["minimaCountSAP"]/data[Mfilter]["minimasSAP"]) + SAP_M_stars_maxima_data = np.array(data[Mfilter]["maximaCountSAP"]/data[Mfilter]["maximasSAP"]) + + SAP_K_stars_minima_data = np.array(data[Kfilter]["minimaCountSAP"]/data[Kfilter]["minimasSAP"]) + SAP_K_stars_maxima_data = np.array(data[Kfilter]["maximaCountSAP"]/data[Kfilter]["maximasSAP"]) + + SAP_G_stars_minima_data = np.array(data[Gfilter]["minimaCountSAP"]/data[Gfilter]["minimasSAP"]) + SAP_G_stars_maxima_data = np.array(data[Gfilter]["maximaCountSAP"]/data[Gfilter]["maximasSAP"]) + + SAP_F_stars_minima_data = np.array(data[Ffilter]["minimaCountSAP"]/data[Ffilter]["minimasSAP"]) + SAP_F_stars_maxima_data = np.array(data[Ffilter]["maximaCountSAP"]/data[Ffilter]["maximasSAP"]) + + SAP_Unknown_stars_minima_data = np.array(data[Unknownfilter]["minimaCountSAP"]/data[Unknownfilter]["minimasSAP"]) + SAP_Unknown_stars_maxima_data = np.array(data[Unknownfilter]["maximaCountSAP"]/data[Unknownfilter]["maximasSAP"]) + np.set_printoptions(linewidth=1000, precision=2) + print("---------------------------------------------------------") + print("SAP Summary:") + SAPtotalMin = 0 + SAPtotalMax = 0 + if(len(SAP_L_stars_minima_data) > 0): + print("L Stars Minima: ", SAP_L_stars_minima_data) + print("L Stars Minima Sum: ", np.nansum(SAP_L_stars_minima_data)) + SAPtotalMin += np.nansum(SAP_L_stars_minima_data) + if(len(SAP_L_stars_maxima_data) > 0): + print("L Stars Maxima: ", SAP_L_stars_maxima_data) + print("L Stars Maxima Sum: ", np.nansum(SAP_L_stars_maxima_data)) + SAPtotalMax += np.nansum(SAP_L_stars_maxima_data) + if(len(SAP_M_stars_minima_data) > 0): + print("M Stars Minima: ", SAP_M_stars_minima_data) + print("M Stars Minima Sum: ", np.nansum(SAP_M_stars_minima_data)) + SAPtotalMin += np.nansum(SAP_M_stars_minima_data) + if(len(SAP_M_stars_maxima_data) > 0): + print("M Stars Maxima: ", SAP_M_stars_maxima_data) + print("M Stars Maxima Sum: ", np.nansum(SAP_M_stars_maxima_data)) + SAPtotalMax += np.nansum(SAP_M_stars_maxima_data) + if(len(SAP_K_stars_minima_data) > 0): + print("K Stars Minima: ", SAP_K_stars_minima_data) + print("K Stars Minima Sum: ", np.nansum(SAP_K_stars_minima_data)) + SAPtotalMin += np.nansum(SAP_K_stars_minima_data) + if(len(SAP_K_stars_maxima_data) > 0): + print("K Stars Maxima: ", SAP_K_stars_maxima_data) + print("K Stars Maxima Sum: ", np.nansum(SAP_K_stars_maxima_data)) + SAPtotalMax += np.nansum(SAP_K_stars_maxima_data) + if(len(SAP_G_stars_minima_data) > 0): + print("G Stars Minima: ", SAP_G_stars_minima_data) + print("G Stars Minima Sum: ", np.nansum(SAP_G_stars_minima_data)) + SAPtotalMin += np.nansum(SAP_G_stars_minima_data) + if(len(SAP_G_stars_maxima_data) > 0): + print("G Stars Maxima: ", SAP_G_stars_maxima_data) + print("G Stars Maxima Sum: ", np.nansum(SAP_G_stars_maxima_data)) + SAPtotalMax += np.nansum(SAP_G_stars_maxima_data) + if(len(SAP_F_stars_minima_data) > 0): + print("F Stars Minima: ", SAP_F_stars_minima_data) + print("F Stars Minima Sum: ", np.nansum(SAP_F_stars_minima_data)) + SAPtotalMin += np.nansum(SAP_F_stars_minima_data) + if(len(SAP_F_stars_maxima_data) > 0): + print("F Stars Maxima: ", SAP_F_stars_maxima_data) + print("F Stars Maxima Sum: ", np.nansum(SAP_F_stars_maxima_data)) + SAPtotalMax += np.nansum(SAP_F_stars_maxima_data) + if(len(SAP_Unknown_stars_minima_data) > 0): + print("Unknown Stars Minima: ", SAP_Unknown_stars_minima_data) + print("Unknown Stars Minima Sum: ", np.nansum(SAP_Unknown_stars_minima_data)) + SAPtotalMin += np.nansum(SAP_Unknown_stars_minima_data) + if(len(SAP_Unknown_stars_maxima_data) > 0): + print("Unknown Stars Maxima: ", SAP_Unknown_stars_maxima_data) + print("Unknown Stars Maxima Sum: ", np.nansum(SAP_Unknown_stars_maxima_data)) + SAPtotalMax += np.nansum(SAP_Unknown_stars_maxima_data) + + print("Total Minima: ", SAPtotalMin) + print("Total Maxima: ", SAPtotalMax) + + # PDCSAP + PDCSAP_L_stars_minima_data = np.array(data[Lfilter]["minimaCountPDCSAP"]/data[Lfilter]["minimasPDCSAP"]) + PDCSAP_L_stars_maxima_data = np.array(data[Lfilter]["maximaCountPDCSAP"]/data[Lfilter]["maximasPDCSAP"]) + PDCSAP_M_stars_minima_data = np.array(data[Mfilter]["minimaCountPDCSAP"]/data[Mfilter]["minimasPDCSAP"]) + PDCSAP_M_stars_maxima_data = np.array(data[Mfilter]["maximaCountPDCSAP"]/data[Mfilter]["maximasPDCSAP"]) + PDCSAP_K_stars_minima_data = np.array(data[Kfilter]["minimaCountPDCSAP"]/data[Kfilter]["minimasPDCSAP"]) + PDCSAP_K_stars_maxima_data = np.array(data[Kfilter]["maximaCountPDCSAP"]/data[Kfilter]["maximasPDCSAP"]) + PDCSAP_G_stars_minima_data = np.array(data[Gfilter]["minimaCountPDCSAP"]/data[Gfilter]["minimasPDCSAP"]) + PDCSAP_G_stars_maxima_data = np.array(data[Gfilter]["maximaCountPDCSAP"]/data[Gfilter]["maximasPDCSAP"]) + PDCSAP_F_stars_minima_data = np.array(data[Ffilter]["minimaCountPDCSAP"]/data[Ffilter]["minimasPDCSAP"]) + PDCSAP_F_stars_maxima_data = np.array(data[Ffilter]["maximaCountPDCSAP"]/data[Ffilter]["maximasPDCSAP"]) + PDCSAP_Unknown_stars_minima_data = np.array(data[Unknownfilter]["minimaCountPDCSAP"]/data[Unknownfilter]["minimasPDCSAP"]) + PDCSAP_Unknown_stars_maxima_data = np.array(data[Unknownfilter]["maximaCountPDCSAP"]/data[Unknownfilter]["maximasPDCSAP"]) + + print("---------------------------------------------------------") + print("PDCSAP Summary:") + PDCSAPtotalMin = 0 + PDCSAPtotalMax = 0 + if(len(PDCSAP_L_stars_minima_data) > 0): + print("L Stars Minima: ", PDCSAP_L_stars_minima_data) + print("L Stars Minima Sum: ", np.nansum(PDCSAP_L_stars_minima_data)) + PDCSAPtotalMin += np.nansum(PDCSAP_L_stars_minima_data) + if(len(PDCSAP_L_stars_maxima_data) > 0): + print("L Stars Maxima: ", PDCSAP_L_stars_maxima_data) + print("L Stars Maxima Sum: ", np.nansum(PDCSAP_L_stars_maxima_data)) + PDCSAPtotalMax += np.nansum(PDCSAP_L_stars_maxima_data) + if(len(PDCSAP_M_stars_minima_data) > 0): + print("M Stars Minima: ", PDCSAP_M_stars_minima_data) + print("M Stars Minima Sum: ", np.nansum(PDCSAP_M_stars_minima_data)) + PDCSAPtotalMin += np.nansum(PDCSAP_M_stars_minima_data) + if(len(PDCSAP_M_stars_maxima_data) > 0): + print("M Stars Maxima: ", PDCSAP_M_stars_maxima_data) + print("M Stars Maxima Sum: ", np.nansum(PDCSAP_M_stars_maxima_data)) + PDCSAPtotalMax += np.nansum(PDCSAP_M_stars_maxima_data) + if(len(PDCSAP_K_stars_minima_data) > 0): + print("K Stars Minima: ", PDCSAP_K_stars_minima_data) + print("K Stars Minima Sum: ", np.nansum(PDCSAP_K_stars_minima_data)) + PDCSAPtotalMin += np.nansum(PDCSAP_K_stars_minima_data) + if(len(PDCSAP_K_stars_maxima_data) > 0): + print("K Stars Maxima: ", PDCSAP_K_stars_maxima_data) + print("K Stars Maxima Sum: ", np.nansum(PDCSAP_K_stars_maxima_data)) + PDCSAPtotalMax += np.nansum(PDCSAP_K_stars_maxima_data) + if(len(PDCSAP_G_stars_minima_data) > 0): + print("G Stars Minima: ", PDCSAP_G_stars_minima_data) + print("G Stars Minima Sum: ", np.nansum(PDCSAP_G_stars_minima_data)) + PDCSAPtotalMin += np.nansum(PDCSAP_G_stars_minima_data) + if(len(PDCSAP_G_stars_maxima_data) > 0): + print("G Stars Maxima: ", PDCSAP_G_stars_maxima_data) + print("G Stars Maxima Sum: ", np.nansum(PDCSAP_G_stars_maxima_data)) + PDCSAPtotalMax += np.nansum(PDCSAP_G_stars_maxima_data) + if(len(PDCSAP_F_stars_minima_data) > 0): + print("F Stars Minima: ", PDCSAP_F_stars_minima_data) + print("F Stars Minima Sum: ", np.nansum(PDCSAP_F_stars_minima_data)) + PDCSAPtotalMin += np.nansum(PDCSAP_F_stars_minima_data) + if(len(PDCSAP_F_stars_maxima_data) > 0): + print("F Stars Maxima: ", PDCSAP_F_stars_maxima_data) + print("F Stars Maxima Sum: ", np.nansum(PDCSAP_F_stars_maxima_data)) + PDCSAPtotalMax += np.nansum(PDCSAP_F_stars_maxima_data) + if(len(PDCSAP_Unknown_stars_minima_data) > 0): + print("Unknown Stars Minima: ", PDCSAP_Unknown_stars_minima_data) + print("Unknown Stars Minima Sum: ", np.nansum(PDCSAP_Unknown_stars_minima_data)) + PDCSAPtotalMin += np.nansum(PDCSAP_Unknown_stars_minima_data) + if(len(PDCSAP_Unknown_stars_maxima_data) > 0): + print("Unknown Stars Maxima: ", PDCSAP_Unknown_stars_maxima_data) + print("Unknown Stars Maxima Sum: ", np.nansum(PDCSAP_Unknown_stars_maxima_data)) + PDCSAPtotalMax += np.nansum(PDCSAP_Unknown_stars_maxima_data) + + print("Total Minima: ", PDCSAPtotalMin) + print("Total Maxima: ", PDCSAPtotalMax) diff --git a/main/astrodatagui/astrodatagui.ui b/main/astrodatagui/astrodatagui.ui index bbd7a2a..6061e27 100644 --- a/main/astrodatagui/astrodatagui.ui +++ b/main/astrodatagui/astrodatagui.ui @@ -968,6 +968,13 @@ + + + + Alt. IDs: + + + @@ -981,23 +988,10 @@ - - - - - 0 - 0 - - + + - - - - - - - - - Alt. IDs: + Spectral Type: @@ -1021,13 +1015,6 @@ - - - - Spectral Type: - - - @@ -1035,19 +1022,6 @@ - - - - - 0 - 0 - - - - - - - - @@ -1077,6 +1051,73 @@ + + + + + 0 + 0 + + + + - + + + + + + + + 0 + 0 + + + + - + + + + + + + Fit Type: + + + + + + + + + Linear + + + bgFitType + + + + + + + Sine + + + bgFitType + + + + + + + Poly + + + bgFitType + + + + + @@ -1156,4 +1197,7 @@ + + + diff --git a/main/astrodatagui/db/StarsDB.py b/main/astrodatagui/db/StarsDB.py index f06b4f9..6dbb851 100644 --- a/main/astrodatagui/db/StarsDB.py +++ b/main/astrodatagui/db/StarsDB.py @@ -1,7 +1,7 @@ from enum import Enum import sqlite3 -supportedFitTypes = ["sine", "linear", "poly"] +supportedFoldedFitTypes = ["sine", "linear", "poly"] class StarDBError(Enum): NO_ERROR = 0 @@ -153,11 +153,12 @@ class StarDB(): self.connection.commit() - def updateFitType(self, mainName, fitType: str): + def updateFoldedFitType(self, mainName, fitType: str): if(fitType in supportedFoldedFitTypes): - self.dbCursor.execute(f"""UPDATE starFoldedFitType - SET foldedFitType = '{fitType}' - WHERE mainName = '{mainName}';""") + print("Updating fit type for ", mainName, " to ", fitType) + self.dbCursor.execute(f"""INSERT OR REPLACE INTO + starFoldedFitType (mainName, foldedFitType) + VALUES ('{mainName}', '{fitType}');""") self.connection.commit() else: raise Exception(f"Fit type {fitType} not supported, must be one of {supportedFitTypes}") @@ -214,8 +215,15 @@ class StarDB(): def getFoldedFitType(self, mainName): res = self.dbCursor.execute(f"""SELECT foldedFitType FROM starFoldedFitType WHERE mainName = \"{mainName}\";""") - ret = res.fetchone()[0] - if(ret in supportedFoldedFitTypes): - return ret - else: + try: + ret = res.fetchone()[0] + print("Fit type for star ", mainName, ": ",ret) + if(ret in supportedFoldedFitTypes): + return ret + else: + print("fit type not supported, return default") + return "sine" + except Exception as e: + print("No custom fit type found, return default") + print(e) return "sine" \ No newline at end of file diff --git a/main/astrodatagui/ui/FlaredetectorWidget.py b/main/astrodatagui/ui/FlaredetectorWidget.py index 24d9e47..262a1ae 100644 --- a/main/astrodatagui/ui/FlaredetectorWidget.py +++ b/main/astrodatagui/ui/FlaredetectorWidget.py @@ -9,6 +9,7 @@ import lightkurve as lk from ...flaredetector.util import * from ...flaredetector.flaredetector import calculateFlareFitsForLightcurve +from ...astrodatagui.db.StarsDB import supportedFoldedFitTypes class FlaredetectorWidget(QtWidgets.QWidget): @@ -64,6 +65,8 @@ class FlaredetectorWidget(QtWidgets.QWidget): def setFitsFile(self, fitsFilePath, mainName: str): print(f"Plotting: {fitsFilePath}") self.currentLC = lk.read(fitsFilePath) + if(isinstance(self.currentLC, lk.lightcurve.KeplerLightCurve)): + print(f"Kepler Quarter: {self.currentLC.hdu[0].header['QUARTER']}") self.currentLCCollection = None self.currentMainName = mainName self.updateFit() @@ -184,6 +187,17 @@ class FlaredetectorWidget(QtWidgets.QWidget): self.ShowQualityState["Enabled"] = enabled self.updatePlot() + def setFoldedFitType(self, foldedFitType): + print("Setting folded Fit Type") + if(foldedFitType in supportedFoldedFitTypes): + self.foldedFitType = foldedFitType + else: + print("Unsupported fit type:", foldedFitType) + print("Setting default: sine") + self.foldedFitType = "sine" + if(hasattr(self, "currentLC")): + self.updatePlot() + def normalizeStichedLightCurve(self, lc): lc.flux = lc[self.fluxType] lc.flux_err = lc[self.fluxErrType] @@ -254,10 +268,15 @@ 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") - phase, sineFit, _ = getFoldedBestFit(lc) - self.figureAxis.plot(phase, sineFit, color="red") - minPhasesBoundsIndices, maxPhasesBoundsIndices = getPhaseRangesNearPeak(getFoldedFitPeakValley(sineFit), phase) - plotPhaseRangesNearPeak((minPhasesBoundsIndices, maxPhasesBoundsIndices), phase, ax=self.figureAxis) + try: + phase, sineFit, _ = getFoldedBestFit(lc, fitType=self.foldedFitType) + self.figureAxis.plot(phase, sineFit, color="red") + print(phase, sineFit) + minPhasesBoundsIndices, maxPhasesBoundsIndices = getPhaseRangesNearPeak(getFoldedFitPeakValley(sineFit), phase) + plotPhaseRangesNearPeak((minPhasesBoundsIndices, maxPhasesBoundsIndices), phase, ax=self.figureAxis) + 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"): diff --git a/main/astrodatagui/ui/NewStarDialog.py b/main/astrodatagui/ui/NewStarDialog.py index c180f3b..01f6bcc 100644 --- a/main/astrodatagui/ui/NewStarDialog.py +++ b/main/astrodatagui/ui/NewStarDialog.py @@ -3,6 +3,8 @@ from PyQt5.QtWidgets import QDialog, QListWidgetItem from PyQt5 import uic import os +from astropy.table import vstack + from ...astrodatadownloader.astrodatadownloader import (ObservationSource, getStarObservations, downloadStarProducts) @@ -49,16 +51,20 @@ class NewStarDialog(QDialog): k2Kadences = [self.cbK2ShortCadence.isChecked(), self.cbK2LongCadence.isChecked()] - obs = getStarObservations(star, keplerKadences, k2Kadences, sources) - if(len(obs) == 0): - self.showErrorMessage("No observations found", - "No observationnal data has been found with the current filters") - return - + allObs = [] + stars = star.split(";") self.listPreview.clear() - for o in obs: - print(o) - self.listPreview.addItem(QListWidgetItem(f"{star} - {o['obs_collection']} - {o['sequence_number']}")) + for s in stars: + s = s.strip() + obs = getStarObservations(s, keplerKadences, k2Kadences, sources) + if(len(obs) == 0): + self.showErrorMessage("No observations found", + "No observationnal data has been found with the current filters") + return + allObs.append(obs) + for o in obs: + self.listPreview.addItem(QListWidgetItem(f"{s} - {o['obs_collection']} - {o['sequence_number']}")) + obs = vstack(allObs) self.currentObservations = obs self.starIdentifier = star diff --git a/main/flaredetector/util.py b/main/flaredetector/util.py index 3c79598..98df7e1 100644 --- a/main/flaredetector/util.py +++ b/main/flaredetector/util.py @@ -94,8 +94,8 @@ def fitPolynomial(phase, flux, degree): def linear(t, k, d): return k*t + d -def fitLinear(phase, flux, degree): - popt, _ = curve_fit(linear, phase, flux, maxfev=300) +def fitLinear(phase, flux): + popt, _ = curve_fit(linear, phase, flux, maxfev=3000) return linear(phase, *popt) def compureRSS(fit, flux): @@ -122,14 +122,23 @@ def getFoldedBestFit(foldedLc, fitType="sine"): flux = flux[filt] polyDegree = 7 fitThreshold = 0.0 - smoothed_flux = np.convolve(flux, np.ones(len(flux)//100)/(len(flux)//100), mode="valid") - peaks, _ = find_peaks(smoothed_flux, height=np.mean(smoothed_flux)) - #print("Num peaks: ", peaks) if(fitType == "sine"): - retFit = fitSingleSine(phase, flux) + try: + print("using sine") + retFit = fitSingleSine(phase, flux) + except: # if its supposed to be a sine, but we cant find one, use a polynomial + print("Use polynomial instead") + retFit = fitPolynomial(phase, flux, polyDegree) + fitType = "poly" elif(fitType == "poly"): - retFit = fitPolynomial(phase, flux, polyDegree) + try: + print("using poly") + retFit = fitPolynomial(phase, flux, polyDegree) + except: # other way around for poly to sine + print("Use sine instead") + retFit = fitSingleSine(phase, flux) + fitType = "sine" elif(fitType == "linear"): retFit = fitLinear(phase, flux) else: @@ -174,6 +183,27 @@ def getFoldedFitPeakValley(sineFit): else: maxima = np.array((len(sineFit)-1), ndmin=1) + # TODO: if theres a minima and maxima extremely close to the edge of data, remove them + if(len(minima) > 1 and len(maxima) > 1): + lenArray = len(sineFit) + minBorder = lenArray * 0.05 + maxBorder = lenArray - minBorder + minInBorder = -1 + maxInBorder = -1 + for mini in minima: + if(mini < minBorder or mini > maxBorder): + minInBorder = mini + break + for maxi in maxima: + if(maxi < minBorder or maxi > maxBorder): + maxInBorder = maxi + break + if(minInBorder > 0 and maxInBorder > 0): + indMin = np.argwhere(minima == minInBorder) + indMax = np.argwhere(maxima == maxInBorder) + minima = np.delete(minima, indMin) + maxima = np.delete(maxima, indMax) + return minima, maxima def findNearestIndexOfValue(array, value): @@ -185,47 +215,153 @@ def getPhaseRangesNearPeak(maxArgs, phase, returnPhaseValue=False): minPhases = phase[maxArgs[0]] maxPhases = phase[maxArgs[1]] totalPhase = abs(phase[0]) + abs(phase[-1]) - - phasePart = totalPhase * 0.3 / (len(minPhases) + len(maxPhases)) - minPhasesBounds = [] - for minPhase in minPhases: - minPhaseBounds = [] - if(minPhase - phasePart < phase[0]): - minPhaseBounds.append((phase[0], minPhase + phasePart)) - minPhaseBounds.append((phase[-1] + (minPhase - phasePart - phase[0]), phase[-1])) - elif(minPhase + phasePart > phase[-1]): - minPhaseBounds.append((minPhase - phasePart, phase[-1])) - minPhaseBounds.append((phase[0], phase[0] + (minPhase + phasePart - phase[-1]))) - else: - minPhaseBounds.append((minPhase - phasePart, minPhase + phasePart)) - minPhasesBounds.append(minPhaseBounds) - - maxPhasesBounds = [] - for maxPhase in maxPhases: - maxPhaseBounds = [] - if(maxPhase - phasePart < phase[0]): - maxPhaseBounds.append((phase[0], maxPhase + phasePart)) - maxPhaseBounds.append((phase[-1] + (maxPhase - phasePart - phase[0]), phase[-1])) - elif(maxPhase + phasePart > phase[-1]): - maxPhaseBounds.append((maxPhase - phasePart, phase[-1])) - maxPhaseBounds.append((phase[0], phase[0] + (maxPhase + phasePart - phase[-1]))) - else: - maxPhaseBounds.append((maxPhase - phasePart, maxPhase + phasePart)) - maxPhasesBounds.append(maxPhaseBounds) - minPhasesBoundsIndices = [] - for minPhaseBounds in minPhasesBounds: - minPhaseBoundsIndices = [] - for l in minPhaseBounds: - minPhaseBoundsIndices.append([phase[findNearestIndexOfValue(phase, lv)] if returnPhaseValue else findNearestIndexOfValue(phase, lv) for lv in l]) - minPhasesBoundsIndices.append(minPhaseBoundsIndices) - maxPhasesBoundsIndices = [] - for maxPhaseBounds in maxPhasesBounds: - maxPhaseBoundsIndices = [] - for l in maxPhaseBounds: - maxPhaseBoundsIndices.append([phase[findNearestIndexOfValue(phase, lv)] if returnPhaseValue else findNearestIndexOfValue(phase, lv) for lv in l]) - maxPhasesBoundsIndices.append(maxPhaseBoundsIndices) + + if((len(minPhases) + len(maxPhases)) > 0): + phasePart = totalPhase * 0.4 / (len(minPhases) + len(maxPhases)) + minPhasesBounds = [] + for minPhase in minPhases: + minPhaseBounds = [] + if(minPhase - phasePart < phase[0]): + minPhaseBounds.append([phase[0], minPhase + phasePart]) + minPhaseBounds.append([phase[-1] + minPhase - phasePart - phase[0], phase[-1]]) + elif(minPhase + phasePart > phase[-1]): + minPhaseBounds.append([minPhase - phasePart, phase[-1]]) + minPhaseBounds.append([phase[0], phase[0] + minPhase + phasePart - phase[-1]]) + else: + minPhaseBounds.append([minPhase - phasePart, minPhase + phasePart]) + minPhasesBounds.append(minPhaseBounds) + + maxPhasesBounds = [] + for maxPhase in maxPhases: + maxPhaseBounds = [] + if(maxPhase - phasePart < phase[0]): + maxPhaseBounds.append([phase[0], maxPhase + phasePart]) + maxPhaseBounds.append([phase[-1] + maxPhase - phasePart - phase[0], phase[-1]]) + elif(maxPhase + phasePart > phase[-1]): + maxPhaseBounds.append([maxPhase - phasePart, phase[-1]]) + maxPhaseBounds.append([phase[0], phase[0] + maxPhase + phasePart - phase[-1]]) + else: + maxPhaseBounds.append([maxPhase - phasePart, maxPhase + phasePart]) + maxPhasesBounds.append(maxPhaseBounds) + + i = 0; j = 0 + while i < len(minPhasesBounds) and j < len(maxPhasesBounds): + #print(f"i: {i}", f"j: {j}") + if(len(minPhasesBounds[i]) == 1): + start_min, end_min = minPhasesBounds[i][0] + elif(len(minPhasesBounds[i]) == 2): + start_min, end_min = minPhasesBounds[i] + + if(len(maxPhasesBounds[j]) == 1): + start_max, end_max = maxPhasesBounds[j][0] + elif(len(maxPhasesBounds[j]) == 2): + start_max, end_max = maxPhasesBounds[j] + + #print(f"start_min type {type(start_min)}, {start_min}") + #print(f"end_min type {type(end_min)}, {end_min}") + #print(f"start_max type {type(start_max)}, {start_max}") + #print(f"end_max type {type(end_max)}, {end_max}") + + if(isinstance(start_min, np.float64) and isinstance(end_min, np.float64) and + isinstance(start_max, np.float64) and isinstance(end_max, np.float64)): + #print("Case 1") + if(start_max < end_min and start_max > start_min): + overlap_start = max(start_min, start_max) + overlap_end = min(end_min, end_max) + midpoint = (overlap_start + overlap_end) / 2 + + minPhasesBounds[i] = [[start_min, midpoint - 0.01]] + maxPhasesBounds[j] = [[midpoint + 0.01, end_max]] + + i += 1 + j += 1 + elif(start_min < end_max and start_max < start_min): + overlap_start = max(start_min, start_max) + overlap_end = min(end_min, end_max) + midpoint = (overlap_start + overlap_end) / 2 + + minPhasesBounds[i] = [[midpoint + 0.01, end_min]] + maxPhasesBounds[j] = [[start_max, midpoint - 0.01]] + + i += 1 + j += 1 + else: + if end_min < start_max: + i += 1 + elif end_max < start_min: + j += 1 + elif(isinstance(start_max, np.float64) and isinstance(end_max, np.float64)): # Case 2 + #print("Case 2") + if(start_min[0] < end_min[0]): + start_min1, end_min1 = start_min[0], start_min[1] + start_min2, end_min2 = end_min[0], end_min[1] + else: + start_min2, end_min2 = start_min[0], start_min[1] + start_min1, end_min1 = end_min[0], end_min[1] + if(start_max < start_min2 and end_max > start_min2): # 1 + midpoint = (start_min2 + end_max) / 2 + + minPhasesBounds[i] = [[start_min1, end_min1], [midpoint + 0.01, end_min2]] + maxPhasesBounds[j] = [[start_max, midpoint - 0.01]] + + i += 1 + j += 1 + elif(start_max > start_min1 and start_max < end_min1): # 2 + midpoint = (start_max + end_min1) / 2 + + minPhasesBounds[i] = [[start_min1, midpoint - 0.01], [start_min2, end_min2]] + maxPhasesBounds[j] = [[midpoint + 0.01, end_max]] + + i += 1 + j += 1 + else: + i += 1 + j += 1 + elif(isinstance(start_min, np.float64) and isinstance(end_min, np.float64)): # Case 3 + #print("Case 3") + if(start_max[0] < end_max[0]): + start_max1, end_max1 = start_max[0], start_max[1] + start_max2, end_max2 = end_max[0], end_max[1] + else: + start_max2, end_max2 = start_max[0], start_max[1] + start_max1, end_max1 = end_max[0], end_max[1] + if(start_min > start_max1 and start_min < end_max1): # 1 + midpoint = (start_min + end_max1) / 2 + + minPhasesBounds[i] = [[midpoint + 0.01, end_min]] + maxPhasesBounds[j] = [[start_max1, midpoint - 0.01], [start_max2, end_max2]] + + i += 1 + j += 1 + elif(start_min < start_max2 and end_min > start_max2): # 2 + midpoint = (start_max2 + end_min) / 2 + + minPhasesBounds[i] = [[start_min, midpoint - 0.01]] + maxPhasesBounds[j] = [[start_max1, end_max1], [midpoint + 0.01, end_max2]] + + i += 1 + j += 1 + else: + i += 1 + j += 1 + else: + print("Rare case of both going over the border, this shouldnt happen, remove them") + minPhasesBounds.pop(i) + maxPhasesBounds.pop(j) + + for minPhaseBounds in minPhasesBounds: + minPhaseBoundsIndices = [] + for l in minPhaseBounds: + minPhaseBoundsIndices.append([phase[findNearestIndexOfValue(phase, lv)] if returnPhaseValue else findNearestIndexOfValue(phase, lv) for lv in l]) + minPhasesBoundsIndices.append(minPhaseBoundsIndices) + + for maxPhaseBounds in maxPhasesBounds: + maxPhaseBoundsIndices = [] + for l in maxPhaseBounds: + maxPhaseBoundsIndices.append([phase[findNearestIndexOfValue(phase, lv)] if returnPhaseValue else findNearestIndexOfValue(phase, lv) for lv in l]) + maxPhasesBoundsIndices.append(maxPhaseBoundsIndices) return minPhasesBoundsIndices, maxPhasesBoundsIndices diff --git a/stars.db b/stars.db index e7934b5..4a6eb5c 100644 Binary files a/stars.db and b/stars.db differ