astrodatagui: FlaredetectorWidget: properly define states of the widget

main/astrodatagui/ui/FlaredetectorWidget.py

@@ -20,44 +20,102 @@ class FlaredetectorWidget(QtWidgets.QWidget):
         self.mainLayout.addWidget(toolbar)
         self.mainLayout.addWidget(fc)
 
-    def plotFitsFile(self, fitsFilePath, mainName: str):
+        self.fluxType = "sap_flux"
-        print(f"Plotting: {fitsFilePath}")
+        self.NormalizeState = {"Enabled": False, "Scale": "unscaled"}
-        self.figureAxis.clear()
+        self.RemoveOutliersState = {"Enabled": False, "Sigma": 5.0}
-        self.currentLC = lk.read(fitsFilePath)
+        self.RemoveNansState = {"Enabled": False}
-        self.currentLC.flux = self.currentLC['sap_flux']
+        self.BinState = {"Enabled": False, "Size": 1}
-        self.currentMainName = mainName
+        self.FlattenState = {"Enabled": False, "WindowLength": 101, "PolynomialOrder": 2}
-        label = f"{mainName} - SAP Flux"
+        self.FoldState = {"Enabled": False, "Period": 1, "EpochTime": 0}
-        self.currentLC.plot(column="sap_flux", label=label, ax=self.figureAxis)
+        self.PeriodogramState = {"Enabled": False, "Method": "lombscargle"}
-        self.figure.canvas.draw_idle()
 
-    def updatePlot(self, normalize: bool, flatten: bool, remOutliers: bool,
+    def setFitsFile(self, fitsFilePath, mainName: str):
-                   remNans: bool, fold: list, binList: list):
+        print(f"Plotting: {fitsFilePath}")
+        self.currentLC = lk.read(fitsFilePath)
+        self.currentMainName = mainName
+
+    def setNormalizeState(self, enabled: bool, scale: str):
+        self.NormalizeState["Enabled"] = enabled
+        if(scale not in ["unscaled", "percent", "ppt", "ppm"]):
+            print(f"Scale not supported: {scale}, setting default unscaled")
+            scale = "unscaled"
+        self.NormalizeState["Scale"] = scale
+
+    def setRemoveOutliersState(self, enabled: bool, sigma: float):
+        self.RemoveOutliersState["Enabled"] = enabled
+        if(sigma < 0):
+            print(f"Negative sigma detected, setting default 5.0")
+            sigma = 5.0
+        self.RemoveOutliersState["Sigma"] = sigma
+
+    def setRemoveNansState(self, enabled: bool):
+        self.RemoveNansState["Enabled"] = enabled
+
+    def setBinState(self, enabled: bool, binSize: float):
+        self.BinState["Enabled"] = enabled
+        if(binSize < 0):
+            print(f"Negative binSize detected, setting default 1")
+            binSize = 1
+        self.BinState["Size"] = binSize
+
+    def setFlattenState(self, enabled: bool, windowLength: int, polyorder: int):
+        self.FlattenState["Enabled"] = enabled
+        if(windowLength < 0):
+            print(f"Negative windowLength detected, setting default 101")
+            windowLength = 101
+        if(polyorder < 0):
+            print(f"Negative polyorder detected, setting default 2")
+            polyorder = 2
+        self.FlattenState["WindowLength"] = windowLength
+        self.FlattenState["PolynomialOrder"] = polyorder
+
+    def setFoldState(self, enabled: bool, period: float, epoch: float):
+        self.FoldState["Enabled"] = enabled
+        if(period < 0):
+            print(f"Negative period detected, setting default 1")
+            period = 1
+        if(epoch < 0):
+            print(f"Negative epoch detected, setting default 0")
+            epoch = 0
+        self.FoldState["Period"] = period
+        self.FoldState["EpochTime"] = epoch
+
+    def setPeriodogramState(self, enabled: bool, method: str):
+        self.PeriodogramState["Enabled"] = enabled
+        if(method not in ["lombscargle", "boxleastsquare", "ls", "bls"]):
+            print(f"Unsupported method detected, setting default lombscargle")
+            method = "lombscargle"
+        self.PeriodogramState["Method"] = method
+
+    def updatePlot(self):
         lc = self.currentLC
         label = f"{self.currentMainName}"
-        if(normalize):
+        if(self.NormalizeState["Enabled"]):
-            lc = lc.normalize()
+            lc = lc.normalize(unit=self.NormalizeState["Scale"])
             label += " - normalized"
-        if(flatten):
+        if(self.RemoveOutliersState["Enabled"]):
-            lc = lc.flatten()
+            lc = lc.remove_outliers(sigma=self.RemoveOutliersState["Sigma"])
-            label += " - flattened"
-        if(remOutliers):
-            lc = lc.remove_outliers()
             label += " - no ol"
-        if(remNans):
+        if(self.RemoveNansState["Enabled"]):
             lc = lc.remove_nans()
             label += " - no nans"
-        if(len(fold) == 3 and fold[0]):
+        if(self.BinState["Enabled"]):
-            period = float(fold[1])
+            lc = lc.bin(time_bin_size=self.RemoveOutliersState["Size"])
-            epoch = float(fold[2])
-            lc = lc.fold(period=period, epoch_time=epoch)
-            label += " - folded"
-        if(len(binList) == 2 and binList[0]):
-            binSize = float(binList[1])
-            lc = lc.bin(time_bin_size=binSize)
             label += " - binned"
+        if(self.FlattenState["Enabled"]):
+            lc = lc.flatten(window_length=self.FlattenState["WindowLength"],
+                            polyorder=self.FlattenState["PolynomialOrder"])
+            label += " - flattened"
+        if(self.FoldState["Enabled"]):
+            lc = lc.fold(period=self.FoldState["Period"],
+                         epoch_time=self.FoldState["EpochTime"])
+            label += " - folded"
+        if(self.PeriodogramState["Enabled"]):
+            lc = lc.to_periodogram(method=self.PeriodogramState["Method"])
+            label = "Periodogram"
 
         self.figureAxis.clear()
-        if(fold[0]):
+        if(self.FoldState["Enabled"]):
             lc.scatter(label=label, ax=self.figureAxis)
         else:
             lc.plot(label=label, ax=self.figureAxis)