Pixel participation (#81)

* new class pixel_participation
* adding broken pixel timeline class
* Resolving conflicts for merge
* Solving further conflicts
* debugging the merge request
* Declaring all class members in init
* removing duplication from pixel_timeline
* Lint code with pre-commit hooks enabled

---------

Co-authored-by: Jean-Philippe Lenain <jlenain@users.noreply.github.com>
Co-authored-by: Halim Ashkar <hashkar@users.noreply.github.com>

src/nectarchain/dqm/camera_monitoring.py

@@ -13,22 +13,42 @@
 class CameraMonitoring(DQMSummary):
     def __init__(self, gaink):
         self.k = gaink
+        self.Pix = None
+        self.Samp = None
+        self.camera = None
+        self.cmap = None
+        self.subarray = None
+        self.event_id = []
+        self.event_times = []
+        self.DrawerTemp = None
+        self.run_start = None
+        self.run_end = None
+        self.DrawerTimes = None
+        self.DrawerTemp11 = None
+        self.DrawerTemp21 = None
+        self.DrawerNum1 = None
+        self.DrawerTimes_new = None
+        self.DrawerTemp12 = None
+        self.DrawerTemp22 = None
+        self.DrawerNum2 = None
+        self.DrawerTemp1_mean = []
+        self.DrawerTemp2_mean = []
+        self.CameraMonitoring_Results_Dict = {}
+        self.ChargeInt_Figures_Dict = {}
+        self.ChargeInt_Figures_Names_Dict = {}
 
     def ConfigureForRun(self, path, Pix, Samp, Reader1):
         # define number of pixels and samples
         self.Pix = Pix
         self.Samp = Samp
 
-        self.camera = CameraGeometry.from_name("NectarCam-003").transform_to(
+        self.camera = Reader1.subarray.tel[0].camera.geometry.transform_to(
             EngineeringCameraFrame()
         )
         self.cmap = "gnuplot2"
 
         self.subarray = Reader1.subarray
 
-        self.event_id = []
-        self.event_times = []
-
         for i, evt1 in enumerate(Reader1):
             self.run_start1 = evt1.nectarcam.tel[0].svc.date
 
@@ -89,8 +109,6 @@ def FinishRun(self):
             self.DrawerTemp22 = self.DrawerTemp21[self.DrawerTimes_new < self.run_end]
             self.DrawerNum2 = self.DrawerNum1[self.DrawerTimes_new < self.run_end]
 
-            self.DrawerTemp1_mean = []
-            self.DrawerTemp2_mean = []
             TotalDrawers = np.max(self.DrawerNum2)
 
             for i in range(TotalDrawers + 1):
@@ -110,7 +128,6 @@ def FinishRun(self):
             print("DRAWER TEMPERATURE COULD NOT BE RETRIEVED!")
 
     def GetResults(self):
-        self.CameraMonitoring_Results_Dict = {}
         try:
             self.CameraMonitoring_Results_Dict[
                 "CAMERA-TEMPERATURE-AVERAGE"
@@ -122,8 +139,6 @@ def GetResults(self):
         return self.CameraMonitoring_Results_Dict
 
     def PlotResults(self, name, FigPath):
-        self.ChargeInt_Figures_Dict = {}
-        self.ChargeInt_Figures_Names_Dict = {}
 
         try:
             fig, disp = plt.subplots()

src/nectarchain/dqm/charge_integration.py

@@ -12,6 +12,32 @@
 class ChargeIntegrationHighLowGain(DQMSummary):
     def __init__(self, gaink):
         self.k = gaink
+        self.Pix = None
+        self.Samp = None
+        self.counter_evt = None
+        self.counter_ped = None
+        self.image_all = []
+        self.peakpos_all = []
+        self.image_ped = []
+        self.peakpos_ped = []
+        self.camera  = None
+        self.cmap = None
+        self.subarray  = None
+        self.integrator = None
+        self.pixelBAD  = None
+        self.image_all = []
+        self.image_all_median = None
+        self.image_all_average = None
+        self.image_all_std = None
+        self.image_all_rms = None
+        self.image_ped = []
+        self.image_ped_median = None
+        self.image_ped_average = None
+        self.image_ped_std = None
+        self.image_ped_rms = None
+        self.ChargeInt_Results_Dict = {}
+        self.ChargeInt_Figures_Dict = {}
+        self.ChargeInt_Figures_Names_Dict = {}
 
     def ConfigureForRun(self, path, Pix, Samp, Reader1):
         # define number of pixels and samples
@@ -21,9 +47,10 @@ def ConfigureForRun(self, path, Pix, Samp, Reader1):
         self.counter_evt = 0
         self.counter_ped = 0
 
-        self.camera = CameraGeometry.from_name("NectarCam-003").transform_to(
+        self.camera = Reader1.subarray.tel[0].camera.geometry.transform_to(
             EngineeringCameraFrame()
         )
+
         self.cmap = "gnuplot2"
 
         self.subarray = Reader1.subarray
@@ -37,11 +64,7 @@ def ConfigureForRun(self, path, Pix, Samp, Reader1):
 
         self.integrator = LocalPeakWindowSum(subarray, config=config)
 
-        self.image_all = []
-        self.peakpos_all = []
 
-        self.image_ped = []
-        self.peakpos_ped = []
 
     def ProcessEvent(self, evt, noped):
         self.pixelBAD = evt.mon.tel[0].pixel_status.hardware_failing_pixels
@@ -106,7 +129,6 @@ def FinishRun(self):
             self.image_ped_rms = np.sqrt(np.sum(self.image_ped**2, axis=0))
 
     def GetResults(self):
-        self.ChargeInt_Results_Dict = {}
 
         if self.k == 0:
             self.ChargeInt_Results_Dict[
@@ -167,8 +189,6 @@ def GetResults(self):
         return self.ChargeInt_Results_Dict
 
     def PlotResults(self, name, FigPath):
-        self.ChargeInt_Figures_Dict = {}
-        self.ChargeInt_Figures_Names_Dict = {}
 
         # titles = ['All', 'Pedestals']
         if self.k == 0:

src/nectarchain/dqm/dqm_summary_processor.py

@@ -13,7 +13,6 @@ def DefineForRun(self, reader1):
             self.FirstReader = reader1
             self.Samp = len(evt1.r0.tel[0].waveform[0][0])
             self.Pix = len(evt1.r0.tel[0].waveform[0])
-
         return self.Pix, self.Samp
 
     def ConfigureForRun(self):
@@ -36,11 +35,12 @@ def PlotResults(
     def WriteAllResults(self, path, DICT):
         data2 = Table()
         data1 = Table()
+        data0 = Table()
         data = Table()
-        hdu, hdu1, hdu2 = None, None, None
+        hdu, hdu0, hdu1, hdu2 = None, None, None, None
         hdulist = fits.HDUList()
         for i, j in DICT.items():
-            if i == "Results_TriggerStatistics":
+            if (i == "Results_TriggerStatistics"):
                 for n2, m2 in j.items():
                     data2[n2] = m2
                 hdu2 = fits.BinTableHDU(data2)
@@ -52,7 +52,13 @@ def WriteAllResults(self, path, DICT):
                 for n1, m1 in j.items():
                     data1[n1] = m1
                 hdu1 = fits.BinTableHDU(data1)
-                hdu1.name = "MWF"
+                hdu1.name = "MWF"    
+
+            elif (i == "Results_PixelTimeline_HighGain") or (i == "Results_PixelTimeline_LowGain"):
+                for n0, m0 in j.items():
+                    data0[n0] = m0 
+                hdu0 = fits.BinTableHDU(data0)
+                hdu0.name = "BPX"
 
             else:
                 for n, m in j.items():
@@ -67,11 +73,17 @@ def WriteAllResults(self, path, DICT):
             hdulist.append(hdu1)
         else:
             print("No MWF studies requests")
+        if hdu0:
+            hdulist.append(hdu0)
+        else:
+            print("No Pixel Timeline studies requests")
         if hdu:
             hdulist.append(hdu)
         else:
             print("No Camera studies requests")
-        FileName = path + "_Results.fits"
+
+
+        FileName = path + '_Results.fits'
         print(FileName)
         hdulist.writeto(FileName, overwrite=True)
         return None

src/nectarchain/dqm/mean_camera_display.py

@@ -8,15 +8,31 @@
 class MeanCameraDisplay_HighLowGain(DQMSummary):
     def __init__(self, gaink):
         self.k = gaink
-        return None
+        self.Pix = None
+        self.Samp = None
+        self.CameraAverage = None
+        self.CameraAverage_ped = None
+        self.counter_evt = None
+        self.counter_ped = None
+        self.camera = None
+        self.cmap = None
+        self.CameraAverage = []
+        self.CameraAverage1 = []
+        self.CameraAverage_ped = []
+        self.CameraAverage_ped1 = []
+        self.CameraAverage_overEvents = None
+        self.CameraAverage_overEvents_overSamp = None
+        self.CameraAverage_ped_overEvents  = None
+        self.CameraAverage_ped_overEvents_overSamp = None
+        self.MeanCameraDisplay_Results_Dict = {}
+        self.MeanCameraDisplay_Figures_Dict = {}
+        self.MeanCameraDisplay_Figures_Names_Dict = {}
 
     def ConfigureForRun(self, path, Pix, Samp, Reader1):
         # define number of pixels and samples
         self.Pix = Pix
         self.Samp = Samp
 
-        self.CameraAverage = np.zeros(self.Pix)
-        self.CameraAverage_ped = np.zeros(self.Pix)
         self.counter_evt = 0
         self.counter_ped = 0
 
@@ -26,8 +42,6 @@ def ConfigureForRun(self, path, Pix, Samp, Reader1):
 
         self.cmap = "gnuplot2"
 
-        self.CameraAverage = []
-        self.CameraAverage_ped = []
 
     def ProcessEvent(self, evt, noped):
         self.pixelBAD = evt.mon.tel[0].pixel_status.hardware_failing_pixels
@@ -72,8 +86,6 @@ def FinishRun(self):
             )
 
     def GetResults(self):
-        # INITIATE DICT
-        self.MeanCameraDisplay_Results_Dict = {}
 
         # ASSIGN RESUTLS TO DICT
         if self.k == 0:
@@ -113,8 +125,6 @@ def GetResults(self):
         return self.MeanCameraDisplay_Results_Dict
 
     def PlotResults(self, name, FigPath):
-        self.MeanCameraDisplay_Figures_Dict = {}
-        self.MeanCameraDisplay_Figures_Names_Dict = {}
 
         # titles = ['All', 'Pedestals']
         if self.k == 0:
@@ -123,14 +133,14 @@ def PlotResults(self, name, FigPath):
             gain_c = "Low"
 
         if self.counter_evt > 0:
-            fig1, self.disp1 = plt.subplots()
-            self.disp1 = CameraDisplay(
+            fig1, disp1 = plt.subplots()
+            disp1 = CameraDisplay(
                 geometry=self.camera[~self.pixelBAD[0]],
                 image=self.CameraAverage_overEvents_overSamp[~self.pixelBAD[0]],
                 cmap=plt.cm.coolwarm,
             )
-            self.disp1.add_colorbar()
-            self.disp1.axes.text(2.0, 0, "Charge (DC)", rotation=90)
+            disp1.add_colorbar()
+            disp1.axes.text(2.0, 0, "Charge (DC)", rotation=90)
             plt.title("Camera average %s gain (ALL)" % gain_c)
 
             self.MeanCameraDisplay_Figures_Dict[
@@ -144,14 +154,14 @@ def PlotResults(self, name, FigPath):
             plt.close()
 
         if self.counter_ped > 0:
-            fig2, self.disp2 = plt.subplots()
-            self.disp2 = CameraDisplay(
+            fig2, disp2 = plt.subplots()
+            disp2 = CameraDisplay(
                 geometry=self.camera[~self.pixelBAD[0]],
                 image=self.CameraAverage_ped_overEvents_overSamp[~self.pixelBAD[0]],
                 cmap=plt.cm.coolwarm,
             )
-            self.disp2.add_colorbar()
-            self.disp2.axes.text(2.0, 0, "Charge (DC)", rotation=90)
+            disp2.add_colorbar()
+            disp2.axes.text(2.0, 0, "Charge (DC)", rotation=90)
             plt.title("Camera average %s gain (PED)" % gain_c)
 
             self.MeanCameraDisplay_Figures_Dict[

src/nectarchain/dqm/mean_waveforms.py

@@ -6,24 +6,30 @@
 class MeanWaveFormsHighLowGain(DQMSummary):
     def __init__(self, gaink):
         self.k = gaink
-        return None
+        self.Pix = None
+        self.Samp = None
+        self.Mwf = None
+        self.Mwf_ped = None
+        self.counter_evt = None
+        self.counter_ped = None
+        self.Mwf_average = None
+        self.Mwf_ped_average = None
+        self.Mwf_Mean_overPix = []
+        self.Mwf_ped_Mean_overPix = []
+        self.MeanWaveForms_Results_Dict = {}
+        self.MeanWaveForms_Figures_Dict = {}
+        self.MeanWaveForms_Figures_Names_Dict = {}
 
     def ConfigureForRun(self, path, Pix, Samp, Reader1):
         # define number of pixels and samples
         self.Pix = Pix
         self.Samp = Samp
-
-        # redefine everything
         self.Mwf = np.zeros((self.Pix, self.Samp))
         self.Mwf_ped = np.zeros((self.Pix, self.Samp))
         self.counter_evt = 0
         self.counter_ped = 0
-
         self.Mwf_average = np.zeros((self.Pix, self.Samp))
         self.Mwf_ped_average = np.zeros((self.Pix, self.Samp))
-        self.Mwf_Mean_overPix = []
-        self.Mwf_ped_Mean_overPix = []
-
         self.wf_list_plot = list(range(1, self.Samp + 1))  # used for plotting later on
 
         return None
@@ -64,8 +70,6 @@ def FinishRun(self):
         return None
 
     def GetResults(self):
-        # INITIATE DICT
-        self.MeanWaveForms_Results_Dict = {}
 
         # ASSIGN RESUTLS TO DICT
         if self.k == 0:
@@ -89,8 +93,6 @@ def GetResults(self):
         return self.MeanWaveForms_Results_Dict
 
     def PlotResults(self, name, FigPath):
-        self.MeanWaveForms_Figures_Dict = {}
-        self.MeanWaveForms_Figures_Names_Dict = {}
 
         wf_list = np.array(self.wf_list_plot)