SGCMarkus/flaredetector
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

way too many updates

Browse Source
This commit is contained in:
SGCMarkus
2024-09-19 12:02:21 +02:00
parent 631fd901b1
commit 3d128d8ecc
9 changed files with 1378 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/astrodatagui/AstrodataGUI.py
+53 -4
View File
@@ -64,6 +64,10 @@ class AstrodataGUI(QtWidgets.QMainWindow):
self.flaredetectorPreview.periodsCalculated.connect(self.updatePeriods) self.flaredetectorPreview.periodsCalculated.connect(self.updatePeriods)
self.flaredetectorPreview.epochCalculated.connect(self.updateEpochPeriod) 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.setupCustomSimbadQueries()
self.show() self.show()
self.loadDB() self.loadDB()
@@ -109,11 +113,12 @@ class AstrodataGUI(QtWidgets.QMainWindow):
if not diag.exec(): if not diag.exec():
return return
try: try:
result = self.simbad.query_object(diag.starIdentifier) results = self.simbad.query_object(diag.starIdentifier)
except: except:
self.showErrorMessage("Simbad Error", "Failed to fetcch information from Simbad, aborting...") self.showErrorMessage("Simbad Error", "Failed to fetcch information from Simbad, aborting...")
return return
results = results.split(";")
for result in results:
try: try:
mainName = result["MAIN_ID"][0] mainName = result["MAIN_ID"][0]
except: except:
@@ -184,14 +189,41 @@ class AstrodataGUI(QtWidgets.QMainWindow):
else: else:
self.lbDistance.setText("-") 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): def starSelected(self, item):
self.currentStarMainName = item.text()
seqs = self.starDB.getStarSequences(item.text()) seqs = self.starDB.getStarSequences(item.text())
infos = self.starDB.getStarInfos(item.text()) infos = self.starDB.getStarInfos(item.text())
altNames = self.starDB.getStarAltNames(item.text()) altNames = self.starDB.getStarAltNames(item.text())
self.foldedFitType = self.starDB.getFoldedFitType(item.text())
self.lbMainID.setText(item.text()) self.lbMainID.setText(item.text())
self.updateSequenceList(seqs) self.updateSequenceList(seqs)
self.updateStarInfo(infos) self.updateStarInfo(infos)
self.updateStarAltNames(altNames) self.updateStarAltNames(altNames)
self.updateStarFoldedFitType(self.foldedFitType)
def sequenceSelected(self, item): def sequenceSelected(self, item):
self.gbPlotOptions.setEnabled(True) self.gbPlotOptions.setEnabled(True)
@@ -202,6 +234,21 @@ class AstrodataGUI(QtWidgets.QMainWindow):
seq = seqText[1] seq = seqText[1]
filePath = self.starDB.getFilePath(mainName, source, seq) filePath = self.starDB.getFilePath(mainName, source, seq)
self.flaredetectorPreview.setFitsFile(filePath, mainName) 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): def updatePeriods(self, periods: list):
self.edPlotFoldPeriod.setText(str(periods[0].value)) self.edPlotFoldPeriod.setText(str(periods[0].value))
@@ -378,18 +425,20 @@ class AstrodataGUI(QtWidgets.QMainWindow):
"DistanceUnit", "DistanceUnit",
"Source", "Source",
"Sequence", "Sequence",
"FilePath"]) "FilePath",
"FitType"])
for starName in self.starDB.getAllStars(): for starName in self.starDB.getAllStars():
sequences = self.starDB.getStarSequences(starName) sequences = self.starDB.getStarSequences(starName)
infos = self.starDB.getStarInfos(starName) infos = self.starDB.getStarInfos(starName)
fitType = self.starDB.getFoldedFitType(starName)
for sourceSeq in sequences: for sourceSeq in sequences:
source = sourceSeq["Source"] source = sourceSeq["Source"]
seq = sourceSeq["Sequence"] seq = sourceSeq["Sequence"]
filePath = self.starDB.getFilePath(starName, source, seq) filePath = self.starDB.getFilePath(starName, source, seq)
allStarsDictList.loc[len(allStarsDictList.index)] = \ allStarsDictList.loc[len(allStarsDictList.index)] = \
[starName, infos["SpType"], infos["RotVel"], infos["RotVelUnit"], [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 = CalcAllFlaresThread(allStarsDictList)
self.calcAllFlaresThread.finished.connect(self.btCountAllFlaresClickedDone) self.calcAllFlaresThread.finished.connect(self.btCountAllFlaresClickedDone)
main/astrodatagui/CalcAllFlaresThread.py
+15 -3
View File
@@ -6,7 +6,12 @@ import pandas as pd
from ..flaredetector.flaredetector import calculateFlareFitsForLightcurve from ..flaredetector.flaredetector import calculateFlareFitsForLightcurve
from ..flaredetector.util import * from ..flaredetector.util import *
import warnings
warnings.filterwarnings("ignore")
def getFlareCount(filesDict): def getFlareCount(filesDict):
try:
print(f"Starting {filesDict['StarName']}, {filesDict['Sequence']}")
lc = read(filesDict["FilePath"]) lc = read(filesDict["FilePath"])
lc.flux = lc["sap_flux"] lc.flux = lc["sap_flux"]
lc.flux_err = lc["sap_flux_err"] lc.flux_err = lc["sap_flux_err"]
@@ -16,7 +21,7 @@ def getFlareCount(filesDict):
sapPeakPeriod = sapPeriodogram.period[findMaxIndices(sapPeriodogram, num=4, distance=100, sortByHighest=True)[0]] sapPeakPeriod = sapPeriodogram.period[findMaxIndices(sapPeriodogram, num=4, distance=100, sortByHighest=True)[0]]
sapEpochTime = getEpochTime(lc) sapEpochTime = getEpochTime(lc)
sapFoldedLC = lc.fold(period=sapPeakPeriod, epoch_time=sapEpochTime) sapFoldedLC = lc.fold(period=sapPeakPeriod, epoch_time=sapEpochTime)
sapPhase, sapSineFit, sapFitType = getFoldedBestFit(sapFoldedLC) sapPhase, sapSineFit, sapFitType = getFoldedBestFit(sapFoldedLC, fitType=filesDict["FitType"])
sapMinima, sapMaxima = getFoldedFitPeakValley(sapSineFit) sapMinima, sapMaxima = getFoldedFitPeakValley(sapSineFit)
sapminPhasesBounds, sapmaxPhasesBounds = getPhaseRangesNearPeak((sapMinima, sapMaxima), sapPhase, returnPhaseValue=True) sapminPhasesBounds, sapmaxPhasesBounds = getPhaseRangesNearPeak((sapMinima, sapMaxima), sapPhase, returnPhaseValue=True)
sapFoldedPeaks = [] sapFoldedPeaks = []
@@ -34,7 +39,7 @@ def getFlareCount(filesDict):
pdcsapPeakPeriod = pdcsapPeriodogram.period[findMaxIndices(pdcsapPeriodogram, num=4, distance=100, sortByHighest=True)[0]] pdcsapPeakPeriod = pdcsapPeriodogram.period[findMaxIndices(pdcsapPeriodogram, num=4, distance=100, sortByHighest=True)[0]]
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) pdcsapPhase, pdcsapSineFit, pdcsapFitType = getFoldedBestFit(pdcsapFoldedLC, fitType=filesDict["FitType"])
pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit) pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit)
pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True) pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True)
pdcsapFoldedPeaks = [] pdcsapFoldedPeaks = []
@@ -75,7 +80,14 @@ def getFlareCount(filesDict):
filesDict["pdcsapPeriodMaxima"] = pdcsapMaxima filesDict["pdcsapPeriodMaxima"] = pdcsapMaxima
filesDict["pdcsapPeriodMaximaBoundaries"] = pdcsapmaxPhasesBounds filesDict["pdcsapPeriodMaximaBoundaries"] = pdcsapmaxPhasesBounds
del lc del lc
print(f"Finished {filesDict['StarName']}, {filesDict['Sequence']}")
return filesDict return filesDict
except Exception as e:
print("------------------------------------------------------------------------")
print(f"Exception in {filesDict['StarName']}, {filesDict['Sequence']}")
print(e)
print("------------------------------------------------------------------------")
return None
class CalcAllFlaresThread(QThread): class CalcAllFlaresThread(QThread):
progress = pyqtSignal(int) progress = pyqtSignal(int)
@@ -89,7 +101,7 @@ class CalcAllFlaresThread(QThread):
def run(self): def run(self):
cpuCount = multiprocessing.cpu_count() cpuCount = multiprocessing.cpu_count()
executor = concurrent.futures.ProcessPoolExecutor(cpuCount) 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"))) resFrame = pd.DataFrame(executor.map(getFlareCount, self.allFlaresDictList.to_dict(orient="records")))
self.finished.emit(resFrame) self.finished.emit(resFrame)
main/astrodatagui/FlareSummaryPlotGUI.py
+823 -1
View File
@@ -9,6 +9,38 @@ import numpy as np
import pandas as pd import pandas as pd
from itertools import compress 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): class FlareSummaryPlotGUI(QWidget):
def __init__(self, starFLareDictList): def __init__(self, starFLareDictList):
@@ -46,6 +78,15 @@ class FlareSummaryPlotGUI(QWidget):
self.btShowPeriods = QPushButton("Show Mean Periods") self.btShowPeriods = QPushButton("Show Mean Periods")
self.btShowPeriods.clicked.connect(self.btShowPeriodsClicked) 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 = QCheckBox("Kepler")
self.cbKepler.setChecked(True) self.cbKepler.setChecked(True)
self.cbK2 = QCheckBox("K2") self.cbK2 = QCheckBox("K2")
@@ -66,11 +107,20 @@ class FlareSummaryPlotGUI(QWidget):
self.cbSpTypeUnknown = QCheckBox("Unknown") self.cbSpTypeUnknown = QCheckBox("Unknown")
self.cbSpTypeUnknown.setChecked(True) 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(QLabel("Plot Types: "), 0, 0)
self.buttonGridLayout.addWidget(self.btShowFlaresPerFile, 0, 1) self.buttonGridLayout.addWidget(self.btShowFlaresPerFile, 0, 1)
self.buttonGridLayout.addWidget(self.btShowFlaresPerStar, 0, 2) self.buttonGridLayout.addWidget(self.btShowFlaresPerStar, 0, 2)
self.buttonGridLayout.addWidget(self.btShowFlaresPerStarNormalized, 0, 3) self.buttonGridLayout.addWidget(self.btShowFlaresPerStarNormalized, 0, 3)
self.buttonGridLayout.addWidget(self.btShowPeriods, 0, 4) 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(QLabel("Sources: "), 1, 0)
self.buttonGridLayout.addWidget(self.cbKepler, 1, 1) 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.cbSpTypeG, 2, 4)
self.buttonGridLayout.addWidget(self.cbSpTypeF, 2, 5) self.buttonGridLayout.addWidget(self.cbSpTypeF, 2, 5)
self.buttonGridLayout.addWidget(self.cbSpTypeUnknown, 2, 6) 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.addLayout(self.buttonGridLayout)
self.mainLayout.addWidget(toolbar) self.mainLayout.addWidget(toolbar)
self.mainLayout.addWidget(fc) self.mainLayout.addWidget(fc)
@@ -134,27 +188,39 @@ class FlareSummaryPlotGUI(QWidget):
self.figureAxis.clear() self.figureAxis.clear()
if(self.cbSpTypeL.isChecked()): if(self.cbSpTypeL.isChecked()):
if(np.any(Lfilter)): if(np.any(Lfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"], marker="o", color="brown", label="L SAP Count") 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") self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"], marker="x", color="brown", label="L PDCSAP Count")
if(self.cbSpTypeM.isChecked()): if(self.cbSpTypeM.isChecked()):
if(np.any(Mfilter)): if(np.any(Mfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"], marker="o", color="red", label="M SAP Count") 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") self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"], marker="x", color="red", label="M PDCSAP Count")
if(self.cbSpTypeK.isChecked()): if(self.cbSpTypeK.isChecked()):
if(np.any(Kfilter)): if(np.any(Kfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"], marker="o", color="orange", label="K SAP Count") 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") self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"], marker="x", color="orange", label="K PDCSAP Count")
if(self.cbSpTypeG.isChecked()): if(self.cbSpTypeG.isChecked()):
if(np.any(Gfilter)): if(np.any(Gfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"], marker="o", color="yellow", label="G SAP Count") 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") self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"], marker="x", color="yellow", label="G PDCSAP Count")
if(self.cbSpTypeF.isChecked()): if(self.cbSpTypeF.isChecked()):
if(np.any(Ffilter)): if(np.any(Ffilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"], marker="o", color="greenyellow", label="F SAP Count") 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") self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"], marker="x", color="greenyellow", label="F PDCSAP Count")
if(self.cbSpTypeUnknown.isChecked()): if(self.cbSpTypeUnknown.isChecked()):
if(np.any(Unknownfilter)): if(np.any(Unknownfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"], marker="o", color="gray", label="Unknown SAP Count") 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.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"], marker="x", color="gray", label="Unknown PDCSAP Count")
self.figureAxis.set_ylabel("Flare count") self.figureAxis.set_ylabel("Flare count")
@@ -224,27 +290,39 @@ class FlareSummaryPlotGUI(QWidget):
self.figureAxis.clear() self.figureAxis.clear()
if(self.cbSpTypeL.isChecked()): if(self.cbSpTypeL.isChecked()):
if(np.any(Lfilter)): if(np.any(Lfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"], marker="o", color="brown", label="L SAP Count") 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") self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"], marker="x", color="brown", label="L PDCSAP Count")
if(self.cbSpTypeM.isChecked()): if(self.cbSpTypeM.isChecked()):
if(np.any(Mfilter)): if(np.any(Mfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"], marker="o", color="red", label="M SAP Count") 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") self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"], marker="x", color="red", label="M PDCSAP Count")
if(self.cbSpTypeK.isChecked()): if(self.cbSpTypeK.isChecked()):
if(np.any(Kfilter)): if(np.any(Kfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"], marker="o", color="orange", label="K SAP Count") 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") self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"], marker="x", color="orange", label="K PDCSAP Count")
if(self.cbSpTypeG.isChecked()): if(self.cbSpTypeG.isChecked()):
if(np.any(Gfilter)): if(np.any(Gfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"], marker="o", color="yellow", label="G SAP Count") 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") self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"], marker="x", color="yellow", label="G PDCSAP Count")
if(self.cbSpTypeF.isChecked()): if(self.cbSpTypeF.isChecked()):
if(np.any(Ffilter)): if(np.any(Ffilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"], marker="o", color="greenyellow", label="F SAP Count") 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") self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"], marker="x", color="greenyellow", label="F PDCSAP Count")
if(self.cbSpTypeUnknown.isChecked()): if(self.cbSpTypeUnknown.isChecked()):
if(np.any(Unknownfilter)): if(np.any(Unknownfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"], marker="o", color="gray", label="Unknown SAP Count") 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.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"], marker="x", color="gray", label="Unknown PDCSAP Count")
self.figureAxis.set_ylabel("Flare count") self.figureAxis.set_ylabel("Flare count")
@@ -317,38 +395,50 @@ class FlareSummaryPlotGUI(QWidget):
self.figureAxis.clear() self.figureAxis.clear()
if(self.cbSpTypeL.isChecked()): if(self.cbSpTypeL.isChecked()):
if(np.any(Lfilter)): if(np.any(Lfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"]/(data[Lfilter]["sapValidSeconds"]/60/60/24/7), self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeaksCount"]/(data[Lfilter]["sapValidSeconds"]/60/60/24/7),
marker="o", color="brown", label="L SAP Count") 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), self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeaksCount"]/(data[Lfilter]["pdcsapValidSeconds"]/60/60/24/7),
marker="x", color="brown", label="L PDCSAP Count") marker="x", color="brown", label="L PDCSAP Count")
if(self.cbSpTypeM.isChecked()): if(self.cbSpTypeM.isChecked()):
if(np.any(Mfilter)): if(np.any(Mfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"]/(data[Mfilter]["sapValidSeconds"]/60/60/24/7), self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeaksCount"]/(data[Mfilter]["sapValidSeconds"]/60/60/24/7),
marker="o", color="red", label="M SAP Count") 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), self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeaksCount"]/(data[Mfilter]["pdcsapValidSeconds"]/60/60/24/7),
marker="x", color="red", label="M PDCSAP Count") marker="x", color="red", label="M PDCSAP Count")
if(self.cbSpTypeK.isChecked()): if(self.cbSpTypeK.isChecked()):
if(np.any(Kfilter)): if(np.any(Kfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"]/(data[Kfilter]["sapValidSeconds"]/60/60/24/7), self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeaksCount"]/(data[Kfilter]["sapValidSeconds"]/60/60/24/7),
marker="o", color="orange", label="K SAP Count") 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), self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeaksCount"]/(data[Kfilter]["pdcsapValidSeconds"]/60/60/24/7),
marker="x", color="orange", label="K PDCSAP Count") marker="x", color="orange", label="K PDCSAP Count")
if(self.cbSpTypeG.isChecked()): if(self.cbSpTypeG.isChecked()):
if(np.any(Gfilter)): if(np.any(Gfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"]/(data[Gfilter]["sapValidSeconds"]/60/60/24/7), self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeaksCount"]/(data[Gfilter]["sapValidSeconds"]/60/60/24/7),
marker="o", color="yellow", label="G SAP Count") 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), self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeaksCount"]/(data[Gfilter]["pdcsapValidSeconds"]/60/60/24/7),
marker="x", color="yellow", label="G PDCSAP Count") marker="x", color="yellow", label="G PDCSAP Count")
if(self.cbSpTypeF.isChecked()): if(self.cbSpTypeF.isChecked()):
if(np.any(Ffilter)): if(np.any(Ffilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"]/(data[Ffilter]["sapValidSeconds"]/60/60/24/7), self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeaksCount"]/(data[Ffilter]["sapValidSeconds"]/60/60/24/7),
marker="o", color="greenyellow", label="F SAP Count") 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), self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeaksCount"]/(data[Ffilter]["pdcsapValidSeconds"]/60/60/24/7),
marker="x", color="greenyellow", label="F PDCSAP Count") marker="x", color="greenyellow", label="F PDCSAP Count")
if(self.cbSpTypeUnknown.isChecked()): if(self.cbSpTypeUnknown.isChecked()):
if(np.any(Unknownfilter)): if(np.any(Unknownfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"]/(data[Unknownfilter]["sapValidSeconds"]/60/60/24/7), self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeaksCount"]/(data[Unknownfilter]["sapValidSeconds"]/60/60/24/7),
marker="o", color="gray", label="Unknown SAP Count") 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), self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeaksCount"]/(data[Unknownfilter]["pdcsapValidSeconds"]/60/60/24/7),
marker="x", color="gray", label="Unknown PDCSAP Count") marker="x", color="gray", label="Unknown PDCSAP Count")
@@ -424,38 +514,50 @@ class FlareSummaryPlotGUI(QWidget):
self.figureAxis.clear() self.figureAxis.clear()
if(self.cbSpTypeL.isChecked()): if(self.cbSpTypeL.isChecked()):
if(np.any(Lfilter)): if(np.any(Lfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeriod"], self.figureAxis.scatter(x[Lfilter], data[Lfilter]["sapPeriod"],
marker="o", color="brown", label="L SAP Period") marker="o", color="brown", label="L SAP Period")
if(self.cbShowPDCSAP.isChecked()):
self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeriod"], self.figureAxis.scatter(x[Lfilter], data[Lfilter]["pdcsapPeriod"],
marker="x", color="brown", label="L PDCSAP Period") marker="x", color="brown", label="L PDCSAP Period")
if(self.cbSpTypeM.isChecked()): if(self.cbSpTypeM.isChecked()):
if(np.any(Mfilter)): if(np.any(Mfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeriod"], self.figureAxis.scatter(x[Mfilter], data[Mfilter]["sapPeriod"],
marker="o", color="red", label="M SAP Period") marker="o", color="red", label="M SAP Period")
if(self.cbShowPDCSAP.isChecked()):
self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeriod"], self.figureAxis.scatter(x[Mfilter], data[Mfilter]["pdcsapPeriod"],
marker="x", color="red", label="M PDCSAP Period") marker="x", color="red", label="M PDCSAP Period")
if(self.cbSpTypeK.isChecked()): if(self.cbSpTypeK.isChecked()):
if(np.any(Kfilter)): if(np.any(Kfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeriod"], self.figureAxis.scatter(x[Kfilter], data[Kfilter]["sapPeriod"],
marker="o", color="orange", label="K SAP Period") marker="o", color="orange", label="K SAP Period")
if(self.cbShowPDCSAP.isChecked()):
self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeriod"], self.figureAxis.scatter(x[Kfilter], data[Kfilter]["pdcsapPeriod"],
marker="x", color="orange", label="K PDCSAP Period") marker="x", color="orange", label="K PDCSAP Period")
if(self.cbSpTypeG.isChecked()): if(self.cbSpTypeG.isChecked()):
if(np.any(Gfilter)): if(np.any(Gfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeriod"], self.figureAxis.scatter(x[Gfilter], data[Gfilter]["sapPeriod"],
marker="o", color="yellow", label="G SAP Period") marker="o", color="yellow", label="G SAP Period")
if(self.cbShowPDCSAP.isChecked()):
self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeriod"], self.figureAxis.scatter(x[Gfilter], data[Gfilter]["pdcsapPeriod"],
marker="x", color="yellow", label="G PDCSAP Period") marker="x", color="yellow", label="G PDCSAP Period")
if(self.cbSpTypeF.isChecked()): if(self.cbSpTypeF.isChecked()):
if(np.any(Ffilter)): if(np.any(Ffilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeriod"], self.figureAxis.scatter(x[Ffilter], data[Ffilter]["sapPeriod"],
marker="o", color="greenyellow", label="F SAP Period") marker="o", color="greenyellow", label="F SAP Period")
if(self.cbShowPDCSAP.isChecked()):
self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeriod"], self.figureAxis.scatter(x[Ffilter], data[Ffilter]["pdcsapPeriod"],
marker="x", color="greenyellow", label="F PDCSAP Period") marker="x", color="greenyellow", label="F PDCSAP Period")
if(self.cbSpTypeUnknown.isChecked()): if(self.cbSpTypeUnknown.isChecked()):
if(np.any(Unknownfilter)): if(np.any(Unknownfilter)):
if(self.cbShowSAP.isChecked()):
self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeriod"], self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["sapPeriod"],
marker="o", color="gray", label="Unknown SAP Period") marker="o", color="gray", label="Unknown SAP Period")
if(self.cbShowPDCSAP.isChecked()):
self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeriod"], self.figureAxis.scatter(x[Unknownfilter], data[Unknownfilter]["pdcsapPeriod"],
marker="x", color="gray", label="Unknown PDCSAP Period") marker="x", color="gray", label="Unknown PDCSAP Period")
@@ -466,10 +568,730 @@ class FlareSummaryPlotGUI(QWidget):
pass pass
def btShowNumMinimaMaximaClicked(self): 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 pass
def btShowFlaresInMinimaMaximaClicked(self): 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 pass
def btShowFlaresInMinimaMaximaPerMinimaMaximaClicked(self): 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)
main/astrodatagui/astrodatagui.ui
+80 -36
View File
@@ -968,6 +968,13 @@
<layout class="QHBoxLayout" name="horizontalLayout_6"> <layout class="QHBoxLayout" name="horizontalLayout_6">
<item> <item>
<layout class="QGridLayout" name="gridLayout"> <layout class="QGridLayout" name="gridLayout">
<item row="1" column="0">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Alt. IDs:</string>
</property>
</widget>
</item>
<item row="2" column="2"> <item row="2" column="2">
<widget class="QLabel" name="lbSpType"> <widget class="QLabel" name="lbSpType">
<property name="sizePolicy"> <property name="sizePolicy">
@@ -981,23 +988,10 @@
</property> </property>
</widget> </widget>
</item> </item>
<item row="3" column="2"> <item row="2" column="0">
<widget class="QLabel" name="lbRotVel"> <widget class="QLabel" name="label_4">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text"> <property name="text">
<string>-</string> <string>Spectral Type: </string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Alt. IDs:</string>
</property> </property>
</widget> </widget>
</item> </item>
@@ -1021,13 +1015,6 @@
</property> </property>
</widget> </widget>
</item> </item>
<item row="2" column="0">
<widget class="QLabel" name="label_4">
<property name="text">
<string>Spectral Type: </string>
</property>
</widget>
</item>
<item row="4" column="0"> <item row="4" column="0">
<widget class="QLabel" name="label_6"> <widget class="QLabel" name="label_6">
<property name="text"> <property name="text">
@@ -1035,19 +1022,6 @@
</property> </property>
</widget> </widget>
</item> </item>
<item row="0" column="2">
<widget class="QLabel" name="lbMainID">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>-</string>
</property>
</widget>
</item>
<item row="3" column="0"> <item row="3" column="0">
<widget class="QLabel" name="label_5"> <widget class="QLabel" name="label_5">
<property name="text"> <property name="text">
@@ -1077,6 +1051,73 @@
</property> </property>
</widget> </widget>
</item> </item>
<item row="3" column="2">
<widget class="QLabel" name="lbRotVel">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>-</string>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="lbMainID">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>-</string>
</property>
</widget>
</item>
<item row="5" column="0">
<widget class="QLabel" name="label_24">
<property name="text">
<string>Fit Type:</string>
</property>
</widget>
</item>
<item row="5" column="2">
<layout class="QVBoxLayout" name="verticalLayout_11">
<item>
<widget class="QRadioButton" name="rbLinearFit">
<property name="text">
<string>Linear</string>
</property>
<attribute name="buttonGroup">
<string notr="true">bgFitType</string>
</attribute>
</widget>
</item>
<item>
<widget class="QRadioButton" name="rbSineFit">
<property name="text">
<string>Sine</string>
</property>
<attribute name="buttonGroup">
<string notr="true">bgFitType</string>
</attribute>
</widget>
</item>
<item>
<widget class="QRadioButton" name="rbPolynomialFit">
<property name="text">
<string>Poly</string>
</property>
<attribute name="buttonGroup">
<string notr="true">bgFitType</string>
</attribute>
</widget>
</item>
</layout>
</item>
</layout> </layout>
</item> </item>
</layout> </layout>
@@ -1156,4 +1197,7 @@
</customwidgets> </customwidgets>
<resources/> <resources/>
<connections/> <connections/>
<buttongroups>
<buttongroup name="bgFitType"/>
</buttongroups>
</ui> </ui>
main/astrodatagui/db/StarsDB.py
+13 -5
View File
@@ -1,7 +1,7 @@
from enum import Enum from enum import Enum
import sqlite3 import sqlite3
supportedFitTypes = ["sine", "linear", "poly"] supportedFoldedFitTypes = ["sine", "linear", "poly"]
class StarDBError(Enum): class StarDBError(Enum):
NO_ERROR = 0 NO_ERROR = 0
@@ -153,11 +153,12 @@ class StarDB():
self.connection.commit() self.connection.commit()
def updateFitType(self, mainName, fitType: str): def updateFoldedFitType(self, mainName, fitType: str):
if(fitType in supportedFoldedFitTypes): if(fitType in supportedFoldedFitTypes):
self.dbCursor.execute(f"""UPDATE starFoldedFitType print("Updating fit type for ", mainName, " to ", fitType)
SET foldedFitType = '{fitType}' self.dbCursor.execute(f"""INSERT OR REPLACE INTO
WHERE mainName = '{mainName}';""") starFoldedFitType (mainName, foldedFitType)
VALUES ('{mainName}', '{fitType}');""")
self.connection.commit() self.connection.commit()
else: else:
raise Exception(f"Fit type {fitType} not supported, must be one of {supportedFitTypes}") raise Exception(f"Fit type {fitType} not supported, must be one of {supportedFitTypes}")
@@ -214,8 +215,15 @@ class StarDB():
def getFoldedFitType(self, mainName): def getFoldedFitType(self, mainName):
res = self.dbCursor.execute(f"""SELECT foldedFitType FROM starFoldedFitType res = self.dbCursor.execute(f"""SELECT foldedFitType FROM starFoldedFitType
WHERE mainName = \"{mainName}\";""") WHERE mainName = \"{mainName}\";""")
try:
ret = res.fetchone()[0] ret = res.fetchone()[0]
print("Fit type for star ", mainName, ": ",ret)
if(ret in supportedFoldedFitTypes): if(ret in supportedFoldedFitTypes):
return ret return ret
else: 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" return "sine"
main/astrodatagui/ui/FlaredetectorWidget.py
+20 -1
View File
@@ -9,6 +9,7 @@ import lightkurve as lk
from ...flaredetector.util import * from ...flaredetector.util import *
from ...flaredetector.flaredetector import calculateFlareFitsForLightcurve from ...flaredetector.flaredetector import calculateFlareFitsForLightcurve
from ...astrodatagui.db.StarsDB import supportedFoldedFitTypes
class FlaredetectorWidget(QtWidgets.QWidget): class FlaredetectorWidget(QtWidgets.QWidget):
@@ -64,6 +65,8 @@ class FlaredetectorWidget(QtWidgets.QWidget):
def setFitsFile(self, fitsFilePath, mainName: str): def setFitsFile(self, fitsFilePath, mainName: str):
print(f"Plotting: {fitsFilePath}") print(f"Plotting: {fitsFilePath}")
self.currentLC = lk.read(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.currentLCCollection = None
self.currentMainName = mainName self.currentMainName = mainName
self.updateFit() self.updateFit()
@@ -184,6 +187,17 @@ class FlaredetectorWidget(QtWidgets.QWidget):
self.ShowQualityState["Enabled"] = enabled self.ShowQualityState["Enabled"] = enabled
self.updatePlot() 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): def normalizeStichedLightCurve(self, lc):
lc.flux = lc[self.fluxType] lc.flux = lc[self.fluxType]
lc.flux_err = lc[self.fluxErrType] lc.flux_err = lc[self.fluxErrType]
@@ -254,10 +268,15 @@ class FlaredetectorWidget(QtWidgets.QWidget):
cycle, foldedIndex = convertStarndardIndexToFoldedIndex(lc, peak["StandardIndex"]) cycle, foldedIndex = convertStarndardIndexToFoldedIndex(lc, peak["StandardIndex"])
self.figureAxis.plot(lc.phase[lc.cycle == cycle][foldedIndex].value, self.figureAxis.plot(lc.phase[lc.cycle == cycle][foldedIndex].value,
lc.flux[lc.cycle == cycle][foldedIndex], "x", color="red") lc.flux[lc.cycle == cycle][foldedIndex], "x", color="red")
phase, sineFit, _ = getFoldedBestFit(lc) try:
phase, sineFit, _ = getFoldedBestFit(lc, fitType=self.foldedFitType)
self.figureAxis.plot(phase, sineFit, color="red") self.figureAxis.plot(phase, sineFit, color="red")
print(phase, sineFit)
minPhasesBoundsIndices, maxPhasesBoundsIndices = getPhaseRangesNearPeak(getFoldedFitPeakValley(sineFit), phase) minPhasesBoundsIndices, maxPhasesBoundsIndices = getPhaseRangesNearPeak(getFoldedFitPeakValley(sineFit), phase)
plotPhaseRangesNearPeak((minPhasesBoundsIndices, maxPhasesBoundsIndices), phase, ax=self.figureAxis) plotPhaseRangesNearPeak((minPhasesBoundsIndices, maxPhasesBoundsIndices), phase, ax=self.figureAxis)
except Exception as e:
print("Failed to get fit")
print(e)
elif(self.PeriodogramState["Enabled"]): elif(self.PeriodogramState["Enabled"]):
lc.plot(label=label, ax=self.figureAxis, view=self.PeriodogramState["View"]) lc.plot(label=label, ax=self.figureAxis, view=self.PeriodogramState["View"])
if(self.PeriodogramState["View"] == "period"): if(self.PeriodogramState["View"] == "period"):
main/astrodatagui/ui/NewStarDialog.py
+11 -5
View File
@@ -3,6 +3,8 @@ from PyQt5.QtWidgets import QDialog, QListWidgetItem
from PyQt5 import uic from PyQt5 import uic
import os import os
from astropy.table import vstack
from ...astrodatadownloader.astrodatadownloader import (ObservationSource, from ...astrodatadownloader.astrodatadownloader import (ObservationSource,
getStarObservations, downloadStarProducts) getStarObservations, downloadStarProducts)
@@ -49,16 +51,20 @@ class NewStarDialog(QDialog):
k2Kadences = [self.cbK2ShortCadence.isChecked(), k2Kadences = [self.cbK2ShortCadence.isChecked(),
self.cbK2LongCadence.isChecked()] self.cbK2LongCadence.isChecked()]
obs = getStarObservations(star, keplerKadences, k2Kadences, sources) allObs = []
stars = star.split(";")
self.listPreview.clear()
for s in stars:
s = s.strip()
obs = getStarObservations(s, keplerKadences, k2Kadences, sources)
if(len(obs) == 0): if(len(obs) == 0):
self.showErrorMessage("No observations found", self.showErrorMessage("No observations found",
"No observationnal data has been found with the current filters") "No observationnal data has been found with the current filters")
return return
allObs.append(obs)
self.listPreview.clear()
for o in obs: for o in obs:
print(o) self.listPreview.addItem(QListWidgetItem(f"{s} - {o['obs_collection']} - {o['sequence_number']}"))
self.listPreview.addItem(QListWidgetItem(f"{star} - {o['obs_collection']} - {o['sequence_number']}")) obs = vstack(allObs)
self.currentObservations = obs self.currentObservations = obs
self.starIdentifier = star self.starIdentifier = star
main/flaredetector/util.py
+155 -19
View File
@@ -94,8 +94,8 @@ def fitPolynomial(phase, flux, degree):
def linear(t, k, d): def linear(t, k, d):
return k*t + d return k*t + d
def fitLinear(phase, flux, degree): def fitLinear(phase, flux):
popt, _ = curve_fit(linear, phase, flux, maxfev=300) popt, _ = curve_fit(linear, phase, flux, maxfev=3000)
return linear(phase, *popt) return linear(phase, *popt)
def compureRSS(fit, flux): def compureRSS(fit, flux):
@@ -122,14 +122,23 @@ def getFoldedBestFit(foldedLc, fitType="sine"):
flux = flux[filt] flux = flux[filt]
polyDegree = 7 polyDegree = 7
fitThreshold = 0.0 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"): if(fitType == "sine"):
try:
print("using sine")
retFit = fitSingleSine(phase, flux) retFit = fitSingleSine(phase, flux)
elif(fitType == "poly"): 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) retFit = fitPolynomial(phase, flux, polyDegree)
fitType = "poly"
elif(fitType == "poly"):
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"): elif(fitType == "linear"):
retFit = fitLinear(phase, flux) retFit = fitLinear(phase, flux)
else: else:
@@ -174,6 +183,27 @@ def getFoldedFitPeakValley(sineFit):
else: else:
maxima = np.array((len(sineFit)-1), ndmin=1) 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 return minima, maxima
def findNearestIndexOfValue(array, value): def findNearestIndexOfValue(array, value):
@@ -185,42 +215,148 @@ def getPhaseRangesNearPeak(maxArgs, phase, returnPhaseValue=False):
minPhases = phase[maxArgs[0]] minPhases = phase[maxArgs[0]]
maxPhases = phase[maxArgs[1]] maxPhases = phase[maxArgs[1]]
totalPhase = abs(phase[0]) + abs(phase[-1]) totalPhase = abs(phase[0]) + abs(phase[-1])
minPhasesBoundsIndices = []
maxPhasesBoundsIndices = []
phasePart = totalPhase * 0.3 / (len(minPhases) + len(maxPhases)) if((len(minPhases) + len(maxPhases)) > 0):
phasePart = totalPhase * 0.4 / (len(minPhases) + len(maxPhases))
minPhasesBounds = [] minPhasesBounds = []
for minPhase in minPhases: for minPhase in minPhases:
minPhaseBounds = [] minPhaseBounds = []
if(minPhase - phasePart < phase[0]): if(minPhase - phasePart < phase[0]):
minPhaseBounds.append((phase[0], minPhase + phasePart)) minPhaseBounds.append([phase[0], minPhase + phasePart])
minPhaseBounds.append((phase[-1] + (minPhase - phasePart - phase[0]), phase[-1])) minPhaseBounds.append([phase[-1] + minPhase - phasePart - phase[0], phase[-1]])
elif(minPhase + phasePart > phase[-1]): elif(minPhase + phasePart > phase[-1]):
minPhaseBounds.append((minPhase - phasePart, phase[-1])) minPhaseBounds.append([minPhase - phasePart, phase[-1]])
minPhaseBounds.append((phase[0], phase[0] + (minPhase + phasePart - phase[-1]))) minPhaseBounds.append([phase[0], phase[0] + minPhase + phasePart - phase[-1]])
else: else:
minPhaseBounds.append((minPhase - phasePart, minPhase + phasePart)) minPhaseBounds.append([minPhase - phasePart, minPhase + phasePart])
minPhasesBounds.append(minPhaseBounds) minPhasesBounds.append(minPhaseBounds)
maxPhasesBounds = [] maxPhasesBounds = []
for maxPhase in maxPhases: for maxPhase in maxPhases:
maxPhaseBounds = [] maxPhaseBounds = []
if(maxPhase - phasePart < phase[0]): if(maxPhase - phasePart < phase[0]):
maxPhaseBounds.append((phase[0], maxPhase + phasePart)) maxPhaseBounds.append([phase[0], maxPhase + phasePart])
maxPhaseBounds.append((phase[-1] + (maxPhase - phasePart - phase[0]), phase[-1])) maxPhaseBounds.append([phase[-1] + maxPhase - phasePart - phase[0], phase[-1]])
elif(maxPhase + phasePart > phase[-1]): elif(maxPhase + phasePart > phase[-1]):
maxPhaseBounds.append((maxPhase - phasePart, phase[-1])) maxPhaseBounds.append([maxPhase - phasePart, phase[-1]])
maxPhaseBounds.append((phase[0], phase[0] + (maxPhase + phasePart - phase[-1]))) maxPhaseBounds.append([phase[0], phase[0] + maxPhase + phasePart - phase[-1]])
else: else:
maxPhaseBounds.append((maxPhase - phasePart, maxPhase + phasePart)) maxPhaseBounds.append([maxPhase - phasePart, maxPhase + phasePart])
maxPhasesBounds.append(maxPhaseBounds) maxPhasesBounds.append(maxPhaseBounds)
minPhasesBoundsIndices = [] 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: for minPhaseBounds in minPhasesBounds:
minPhaseBoundsIndices = [] minPhaseBoundsIndices = []
for l in minPhaseBounds: for l in minPhaseBounds:
minPhaseBoundsIndices.append([phase[findNearestIndexOfValue(phase, lv)] if returnPhaseValue else findNearestIndexOfValue(phase, lv) for lv in l]) minPhaseBoundsIndices.append([phase[findNearestIndexOfValue(phase, lv)] if returnPhaseValue else findNearestIndexOfValue(phase, lv) for lv in l])
minPhasesBoundsIndices.append(minPhaseBoundsIndices) minPhasesBoundsIndices.append(minPhaseBoundsIndices)
maxPhasesBoundsIndices = []
for maxPhaseBounds in maxPhasesBounds: for maxPhaseBounds in maxPhasesBounds:
maxPhaseBoundsIndices = [] maxPhaseBoundsIndices = []
for l in maxPhaseBounds: for l in maxPhaseBounds:
stars.db
BIN
View File
Binary file not shown.