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.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,11 +113,12 @@ 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:
@@ -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)
main/astrodatagui/CalcAllFlaresThread.py
+15 -3
View File
@@ -6,7 +6,12 @@ import pandas as pd
from ..flaredetector.flaredetector import calculateFlareFitsForLightcurve
from ..flaredetector.util import *
import warnings
warnings.filterwarnings("ignore")
def getFlareCount(filesDict):
try:
print(f"Starting {filesDict['StarName']}, {filesDict['Sequence']}")
lc = read(filesDict["FilePath"])
lc.flux = lc["sap_flux"]
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]]
sapEpochTime = getEpochTime(lc)
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)
sapminPhasesBounds, sapmaxPhasesBounds = getPhaseRangesNearPeak((sapMinima, sapMaxima), sapPhase, returnPhaseValue=True)
sapFoldedPeaks = []
@@ -34,7 +39,7 @@ def getFlareCount(filesDict):
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)
pdcsapPhase, pdcsapSineFit, pdcsapFitType = getFoldedBestFit(pdcsapFoldedLC, fitType=filesDict["FitType"])
pdcsapMinima, pdcsapMaxima = getFoldedFitPeakValley(pdcsapSineFit)
pdcsapminPhasesBounds, pdcsapmaxPhasesBounds = getPhaseRangesNearPeak((pdcsapMinima, pdcsapMaxima), pdcsapPhase, returnPhaseValue=True)
pdcsapFoldedPeaks = []
@@ -75,7 +80,14 @@ def getFlareCount(filesDict):
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)
main/astrodatagui/FlareSummaryPlotGUI.py
+823 -1
View File
@@ -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,27 +188,39 @@ class FlareSummaryPlotGUI(QWidget):
self.figureAxis.clear()
if(self.cbSpTypeL.isChecked()):
if(np.any(Lfilter)):
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)):
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)):
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)):
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)):
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)):
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")
@@ -224,27 +290,39 @@ class FlareSummaryPlotGUI(QWidget):
self.figureAxis.clear()
if(self.cbSpTypeL.isChecked()):
if(np.any(Lfilter)):
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)):
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)):
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)):
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)):
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)):
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")
@@ -317,38 +395,50 @@ class FlareSummaryPlotGUI(QWidget):
self.figureAxis.clear()
if(self.cbSpTypeL.isChecked()):
if(np.any(Lfilter)):
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)):
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)):
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)):
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)):
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)):
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")
@@ -424,38 +514,50 @@ class FlareSummaryPlotGUI(QWidget):
self.figureAxis.clear()
if(self.cbSpTypeL.isChecked()):
if(np.any(Lfilter)):
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)):
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)):
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)):
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)):
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)):
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")
@@ -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)
main/astrodatagui/astrodatagui.ui
+80 -36
View File
@@ -968,6 +968,13 @@
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<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">
<widget class="QLabel" name="lbSpType">
<property name="sizePolicy">
@@ -981,23 +988,10 @@
</property>
</widget>
</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>
<item row="2" column="0">
<widget class="QLabel" name="label_4">
<property name="text">
<string>-</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Alt. IDs:</string>
<string>Spectral Type: </string>
</property>
</widget>
</item>
@@ -1021,13 +1015,6 @@
</property>
</widget>
</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">
<widget class="QLabel" name="label_6">
<property name="text">
@@ -1035,19 +1022,6 @@
</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="3" column="0">
<widget class="QLabel" name="label_5">
<property name="text">
@@ -1077,6 +1051,73 @@
</property>
</widget>
</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>
</item>
</layout>
@@ -1156,4 +1197,7 @@
</customwidgets>
<resources/>
<connections/>
<buttongroups>
<buttongroup name="bgFitType"/>
</buttongroups>
</ui>
main/astrodatagui/db/StarsDB.py
+13 -5
View File
@@ -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}\";""")
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"
main/astrodatagui/ui/FlaredetectorWidget.py
+20 -1
View File
@@ -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)
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"):
main/astrodatagui/ui/NewStarDialog.py
+11 -5
View File
@@ -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)
allObs = []
stars = star.split(";")
self.listPreview.clear()
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
self.listPreview.clear()
allObs.append(obs)
for o in obs:
print(o)
self.listPreview.addItem(QListWidgetItem(f"{star} - {o['obs_collection']} - {o['sequence_number']}"))
self.listPreview.addItem(QListWidgetItem(f"{s} - {o['obs_collection']} - {o['sequence_number']}"))
obs = vstack(allObs)
self.currentObservations = obs
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):
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"):
try:
print("using sine")
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)
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"):
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,42 +215,148 @@ def getPhaseRangesNearPeak(maxArgs, phase, returnPhaseValue=False):
minPhases = phase[maxArgs[0]]
maxPhases = phase[maxArgs[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 = []
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]))
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])))
minPhaseBounds.append([minPhase - phasePart, phase[-1]])
minPhaseBounds.append([phase[0], phase[0] + minPhase + phasePart - phase[-1]])
else:
minPhaseBounds.append((minPhase - phasePart, minPhase + phasePart))
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]))
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])))
maxPhaseBounds.append([maxPhase - phasePart, phase[-1]])
maxPhaseBounds.append([phase[0], phase[0] + maxPhase + phasePart - phase[-1]])
else:
maxPhaseBounds.append((maxPhase - phasePart, maxPhase + phasePart))
maxPhaseBounds.append([maxPhase - phasePart, maxPhase + phasePart])
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:
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:
stars.db
BIN
View File
Binary file not shown.