From 4ac4475aa7a8393a6f85e52b58173b14cdf5c7c9 Mon Sep 17 00:00:00 2001
From: jlenain <jeanphilippe.lenain@free.fr>
Date: Tue, 25 Apr 2023 16:30:52 +0200
Subject: [PATCH 01/19] Adapt package dependencies to prepare for ctapipe-0.19

---
 environment.yml |  7 ++-----
 pyproject.toml  | 13 +++++++------
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/environment.yml b/environment.yml
index b2917a19..311aaeee 100644
--- a/environment.yml
+++ b/environment.yml
@@ -3,13 +3,10 @@ channels:
   - default
   - conda-forge
 dependencies:
-  - python=3.8 # nail the python version, so conda does not try upgrading / downgrading
-  - ctapipe=0.12
+  - python>=3.8 # nail the python version, so conda does not try upgrading / downgrading
+  - ctapipe=0.19
   - ctapipe-io-nectarcam
-  - numpy=1.22 # higher versions >=1.23 don't work due to astropy4 dependency in ctapipe0.12
   - jupyterlab
-  - protozfits=2.0
-  - pytables>=3.7
   - pytest-runner
   - pip
   - pandas
diff --git a/pyproject.toml b/pyproject.toml
index d9040ea0..6b790d20 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -15,15 +15,16 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Physics",
     "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10"
 ]
-requires-python = "~=3.8"
+requires-python = ">=3.8"
 dependencies = [
-    "astropy~=4.2",
-    "ctapipe~=0.12",
+    "browser_cookie3",
+    "ctapipe~=0.19",
     "ctapipe-io-nectarcam",
-    "numpy~=1.22",
-    "protozfits~=2.0",
-    "tables>=3.7",
+    "mechanize",
+    "pandas",
 ]
 dynamic = ["version"]
 

From 164713c190c30208e074b77163b16bb16adfdab6 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Thu, 15 Jun 2023 16:42:22 +0200
Subject: [PATCH 02/19] Upgrade to ctapipe 0.19.2

---
 environment.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/environment.yml b/environment.yml
index 311aaeee..cf35b4f2 100644
--- a/environment.yml
+++ b/environment.yml
@@ -4,7 +4,7 @@ channels:
   - conda-forge
 dependencies:
   - python>=3.8 # nail the python version, so conda does not try upgrading / downgrading
-  - ctapipe=0.19
+  - ctapipe=0.19.2
   - ctapipe-io-nectarcam
   - jupyterlab
   - pytest-runner

From fddc25ba1329a6ba3424cbfeb56a49192818b184 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Thu, 15 Jun 2023 16:49:32 +0200
Subject: [PATCH 03/19] Pin ctapipe_io_nectarcam version to 0.1.3

---
 environment.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/environment.yml b/environment.yml
index cf35b4f2..034e89f6 100644
--- a/environment.yml
+++ b/environment.yml
@@ -5,7 +5,7 @@ channels:
 dependencies:
   - python>=3.8 # nail the python version, so conda does not try upgrading / downgrading
   - ctapipe=0.19.2
-  - ctapipe-io-nectarcam
+  - ctapipe-io-nectarcam=0.1.3
   - jupyterlab
   - pytest-runner
   - pip

From 93c3ca6225ff4c696f299d814d96930217c1f828 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Thu, 15 Jun 2023 16:54:13 +0200
Subject: [PATCH 04/19] Install pinned version of ctapipe-io-nectarcam via
 PyPI, the time for the conda-forge package to be built.

---
 environment.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/environment.yml b/environment.yml
index 034e89f6..917133c5 100644
--- a/environment.yml
+++ b/environment.yml
@@ -5,7 +5,6 @@ channels:
 dependencies:
   - python>=3.8 # nail the python version, so conda does not try upgrading / downgrading
   - ctapipe=0.19.2
-  - ctapipe-io-nectarcam=0.1.3
   - jupyterlab
   - pytest-runner
   - pip
@@ -13,3 +12,4 @@ dependencies:
   - pip:
       - mechanize
       - browser-cookie3
+      - ctapipe-io-nectarcam=0.1.3

From 989f209bc389c921ea029afb4b0045f4727c921a Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Thu, 15 Jun 2023 16:55:57 +0200
Subject: [PATCH 05/19] Fixed typo

---
 environment.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/environment.yml b/environment.yml
index 917133c5..a344642c 100644
--- a/environment.yml
+++ b/environment.yml
@@ -12,4 +12,4 @@ dependencies:
   - pip:
       - mechanize
       - browser-cookie3
-      - ctapipe-io-nectarcam=0.1.3
+      - ctapipe-io-nectarcam==0.1.3

From ae0faa8859d32eeaaca02b6474e94edcff2db034 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Thu, 15 Jun 2023 21:45:45 +0200
Subject: [PATCH 06/19] Put ctapipe_io_nectarcam dependency back into conda
 dependencies, instead of a pip dependency (was a temporary hack, until the
 last release of ctapipe_io_nectarcam was published as a conda-forge package).

---
 environment.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/environment.yml b/environment.yml
index a344642c..cf35b4f2 100644
--- a/environment.yml
+++ b/environment.yml
@@ -5,6 +5,7 @@ channels:
 dependencies:
   - python>=3.8 # nail the python version, so conda does not try upgrading / downgrading
   - ctapipe=0.19.2
+  - ctapipe-io-nectarcam
   - jupyterlab
   - pytest-runner
   - pip
@@ -12,4 +13,3 @@ dependencies:
   - pip:
       - mechanize
       - browser-cookie3
-      - ctapipe-io-nectarcam==0.1.3

From 42b1f9d246f495485ec1a44b3b20ecce94c02b70 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Thu, 15 Jun 2023 21:55:30 +0200
Subject: [PATCH 07/19] Pin ctapipe 0.19.1 (same as for ctapipe_io_nectarcam)

---
 environment.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/environment.yml b/environment.yml
index cf35b4f2..2b38d9af 100644
--- a/environment.yml
+++ b/environment.yml
@@ -4,7 +4,7 @@ channels:
   - conda-forge
 dependencies:
   - python>=3.8 # nail the python version, so conda does not try upgrading / downgrading
-  - ctapipe=0.19.2
+  - ctapipe=0.19.1
   - ctapipe-io-nectarcam
   - jupyterlab
   - pytest-runner

From f112f028805e76f35d0af32abf5524d67e105ef9 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Fri, 16 Jun 2023 14:16:31 +0200
Subject: [PATCH 08/19]  - minimize the RAM needed by not initializing arrays
 before reading events in waveformsContainer(s)  - Update to ctapipe0.19

---
 .../calibration/container/charge.py           |  7 ++-
 .../calibration/container/utils.py            |  5 ++
 .../calibration/container/waveforms.py        | 51 ++++++++++++++++---
 .../ggrolleron/load_wfs_compute_charge.py     |  2 +-
 4 files changed, 54 insertions(+), 11 deletions(-)

diff --git a/src/nectarchain/calibration/container/charge.py b/src/nectarchain/calibration/container/charge.py
index ce3c79e9..add0e784 100644
--- a/src/nectarchain/calibration/container/charge.py
+++ b/src/nectarchain/calibration/container/charge.py
@@ -34,6 +34,7 @@
 from numba import guvectorize, float64, int64, bool_
 
 from .waveforms import WaveformsContainer,WaveformsContainers
+from .utils import CtaPipeExtractor
 
 
 
@@ -131,6 +132,7 @@ def __init__(self,charge_hg,charge_lg,peak_hg,peak_lg,run_number,pixels_id,neven
         self.event_id = np.zeros((self.nevents),dtype = np.uint16)
         self.trig_pattern_all = np.zeros((self.nevents,self.CAMERA.n_pixels,4),dtype = bool)
 
+
     @classmethod
     def from_waveforms(cls,waveformContainer : WaveformsContainer,method : str = "FullWaveformSum",**kwargs) : 
         """ create a new ChargeContainer from a WaveformsContainer
@@ -299,11 +301,12 @@ def compute_charge(waveformContainer : WaveformsContainer,channel : int,method :
 
         log.debug(f"Extracting charges with method {method} and extractor_kwargs {extractor_kwargs}")
         ImageExtractor = eval(method)(waveformContainer.subarray,**extractor_kwargs)
+
         if channel == constants.HIGH_GAIN:
-            out = np.array([ImageExtractor(waveformContainer.wfs_hg[i],waveformContainer.TEL_ID,channel) for i in range(len(waveformContainer.wfs_hg))]).transpose(1,0,2)
+            out = np.array([CtaPipeExtractor.get_image_peak_time(ImageExtractor(waveformContainer.wfs_hg[i],waveformContainer.TEL_ID,channel,waveformContainer.broken_pixels_hg)) for i in range(len(waveformContainer.wfs_hg))]).transpose(1,0,2)
             return out[0],out[1]
         elif channel == constants.LOW_GAIN:
-            out = np.array([ImageExtractor(waveformContainer.wfs_lg[i],waveformContainer.TEL_ID,channel) for i in range(len(waveformContainer.wfs_lg))]).transpose(1,0,2)
+            out = np.array([CtaPipeExtractor.get_image_peak_time(ImageExtractor(waveformContainer.wfs_lg[i],waveformContainer.TEL_ID,channel,waveformContainer.broken_pixels_lg)) for i in range(len(waveformContainer.wfs_lg))]).transpose(1,0,2)
             return out[0],out[1]
         else :
             raise ArgumentError(f"channel must be {constants.LOW_GAIN} or {constants.HIGH_GAIN}")
diff --git a/src/nectarchain/calibration/container/utils.py b/src/nectarchain/calibration/container/utils.py
index 4f466254..519d1e04 100644
--- a/src/nectarchain/calibration/container/utils.py
+++ b/src/nectarchain/calibration/container/utils.py
@@ -10,6 +10,8 @@
 from pathlib import Path
 from typing import List,Tuple
 
+from ctapipe.containers import DL1CameraContainer 
+
 
 import logging
 logging.basicConfig(format='%(asctime)s %(name)s %(levelname)s %(message)s')
@@ -180,3 +182,6 @@ def chainEventSource(list : list,max_events : int = None) : #useless with ctapip
         else :
             return ChainGenerator.chain(list[0],ChainGenerator.chainEventSource(list[1:]))
 
+class CtaPipeExtractor():
+    def get_image_peak_time(cameraContainer : DL1CameraContainer) : 
+        return cameraContainer.image, cameraContainer.peak_time
diff --git a/src/nectarchain/calibration/container/waveforms.py b/src/nectarchain/calibration/container/waveforms.py
index b85286b2..bceb9b94 100644
--- a/src/nectarchain/calibration/container/waveforms.py
+++ b/src/nectarchain/calibration/container/waveforms.py
@@ -40,7 +40,7 @@ def __new__(cls,*args,**kwargs) :
         obj = object.__new__(cls)
         return obj
 
-    def __init__(self,run_number : int,max_events : int = None,nevents : int = -1,run_file = None):
+    def __init__(self,run_number : int,max_events : int = None,nevents : int = -1,run_file = None, init_arrays : bool = False):
         """construtor
 
         Args:
@@ -52,7 +52,9 @@ def __init__(self,run_number : int,max_events : int = None,nevents : int = -1,ru
         """
 
         self.__run_number = run_number
-        #gerer ici le fait de traiter plusieurs fichiers ou simplement 1 par 1
+        self.__run_file = run_file
+        self.__max_events = max_events
+
         self.__reader = WaveformsContainer.load_run(run_number,max_events,run_file = run_file)
 
         #from reader members
@@ -68,12 +70,20 @@ def __init__(self,run_number : int,max_events : int = None,nevents : int = -1,ru
         #run properties
         if nevents != -1 :
             self.__nevents = nevents if max_events is None else min(max_events,nevents) #self.check_events()
+            self.__reader = None
         else :
             self.__nevents = self.check_events()
-            #reload file (bc check_events has drained reader generator)
-            self.__reader = WaveformsContainer.load_run(run_number,max_events,run_file = run_file)
+            
         log.info(f"N_events : {self.nevents}")
 
+        if init_arrays : 
+            self.__init_arrays()
+            
+    def __init_arrays(self,**kwargs) : 
+        log.debug('creation of the EventSource reader')
+        self.__reader = WaveformsContainer.load_run(self.__run_number,self.__max_events,run_file = self.__run_file)
+        
+        log.debug("create wfs, ucts, event properties and triger pattern arrays")
         #define zeros members which will be filled therafter
         self.wfs_hg = np.zeros((self.nevents,self.npixels,self.nsamples),dtype = np.uint16)
         self.wfs_lg = np.zeros((self.nevents,self.npixels,self.nsamples),dtype = np.uint16)
@@ -86,6 +96,14 @@ def __init__(self,run_number : int,max_events : int = None,nevents : int = -1,ru
         #self.trig_pattern = np.zeros((self.nevents,self.npixels),dtype = bool)
         #self.multiplicity = np.zeros((self.nevents,self.npixels),dtype = np.uint16)
 
+        self.__broken_pixels_hg = np.zeros((self.npixels),dtype = bool)
+        self.__broken_pixels_lg = np.zeros((self.npixels),dtype = bool)
+
+
+    def __compute_broken_pixels(self,**kwargs) : 
+        log.warning("computation of broken pixels is not yet implemented")
+        self.__broken_pixels_hg = np.zeros((self.npixels),dtype = bool)
+        self.__broken_pixels_lg = np.zeros((self.npixels),dtype = bool)
 
     @staticmethod
     def load_run(run_number : int,max_events : int = None, run_file = None) : 
@@ -98,8 +116,8 @@ def load_run(run_number : int,max_events : int = None, run_file = None) :
         Returns:
             List[ctapipe_io_nectarcam.NectarCAMEventSource]: List of EventSource for each run files
         """
-        generic_filename,filenames = DataManagement.findrun(run_number)
         if run_file is None : 
+            generic_filename,_ = DataManagement.findrun(run_number)
             log.info(f"{str(generic_filename)} will be loaded")
             eventsource = NectarCAMEventSource(input_url=generic_filename,max_events=max_events)
         else :  
@@ -135,6 +153,9 @@ def load_wfs(self,compute_trigger_patern = False):
         Args:
             compute_trigger_patern (bool, optional): To recompute on our side the trigger patern. Defaults to False.
         """
+        if not(hasattr(self, "wfs_hg")) : 
+            self.__init_arrays()
+
         wfs_hg_tmp=np.zeros((self.npixels,self.nsamples),dtype = np.uint16)
         wfs_lg_tmp=np.zeros((self.npixels,self.nsamples),dtype = np.uint16)
 
@@ -159,7 +180,7 @@ def load_wfs(self,compute_trigger_patern = False):
             self.wfs_hg[i] = wfs_hg_tmp
             self.wfs_lg[i] = wfs_lg_tmp
 
-
+        self.__compute_broken_pixels()
 
         #if compute_trigger_patern and np.max(self.trig_pattern) == 0:
         #    self.compute_trigger_patern()
@@ -262,6 +283,8 @@ def load(path : str) :
             table_trigger = hdul[4].data
             cls.trig_pattern_all = table_trigger["trig_pattern_all"]
 
+        cls.__compute_broken_pixels()
+
         return cls
 
     
@@ -345,6 +368,13 @@ def select_waveforms_lg(self,pixel_id : np.ndarray) :
         res = res.transpose(res.shape[1],res.shape[0],res.shape[2])
         return res
 
+
+    @property 
+    def _run_file(self) : return self.__run_file 
+
+    @property
+    def _max_events(self) : return self.__max_events
+
     @property
     def reader(self) : return self.__reader
 
@@ -369,7 +399,12 @@ def nevents(self) : return self.__nevents
     @property
     def run_number(self) : return self.__run_number
 
+    @property
+    def broken_pixels_hg(self) : return self.__broken_pixels_hg
 
+    @property
+    def broken_pixels_lg(self) : return self.__broken_pixels_lg
+    
     #physical properties
     @property
     def multiplicity(self) :  return np.uint16(np.count_nonzero(self.trig_pattern,axis = 1))
@@ -395,7 +430,7 @@ def __new__(cls,*args,**kwargs) :
         obj = object.__new__(cls)
         return obj
     
-    def __init__(self,run_number : int,max_events : int = None) :
+    def __init__(self,run_number : int,max_events : int = None, init_arrays : bool = False) :
         """initialize the waveformsContainer list inside the main object
 
         Args:
@@ -407,7 +442,7 @@ def __init__(self,run_number : int,max_events : int = None) :
         self.waveformsContainer = []
         self.__nWaveformsContainer = 0
         for i,file in enumerate(filenames) : 
-            self.waveformsContainer.append(WaveformsContainer(run_number,max_events=max_events,run_file=file))
+            self.waveformsContainer.append(WaveformsContainer(run_number,max_events=max_events,run_file=file, init_arrays= init_arrays))
             self.__nWaveformsContainer += 1
             if not(max_events is None) : max_events -= self.waveformsContainer[i].nevents
             log.info(f'WaveformsContainer number {i} is created')
diff --git a/src/nectarchain/user_scripts/ggrolleron/load_wfs_compute_charge.py b/src/nectarchain/user_scripts/ggrolleron/load_wfs_compute_charge.py
index 1993ce09..10112ce5 100644
--- a/src/nectarchain/user_scripts/ggrolleron/load_wfs_compute_charge.py
+++ b/src/nectarchain/user_scripts/ggrolleron/load_wfs_compute_charge.py
@@ -165,7 +165,7 @@ def load_wfs_charge_split(i,runs_list,max_events,overwrite,charge_childpath,extr
      
     log.info("splitting wafevorms extraction with raw data list files")
     log.debug(f"creation of the WaveformsContainers")
-    wfs = WaveformsContainers(runs_list[i],max_events = max_events[i])
+    wfs = WaveformsContainers(runs_list[i],max_events = max_events[i],init_arrays = False)
     log.info(f"computation of charge with {charge_childpath}")
     log.info("splitting charge computation with raw data list files")
     charge = ChargeContainers()

From c38d9330623e3fa7b72478b000c3d78de5a9b75e Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Fri, 16 Jun 2023 16:20:07 +0200
Subject: [PATCH 09/19] Bump ctapipe version into CI tests.

---
 .github/workflows/ci.yml | 4 ++--
 pyproject.toml           | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ddc227bc..2ec1a7c4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -31,8 +31,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.8]
-        ctapipe-version: [v0.12.0]
+        python-version: [3.8, 3.9, 3.10, 3.11]
+        ctapipe-version: [v0.19.1]
 
     defaults:
       run:
diff --git a/pyproject.toml b/pyproject.toml
index 6b790d20..926e16f6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,7 +16,8 @@ classifiers = [
     "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10"
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11"
 ]
 requires-python = ">=3.8"
 dependencies = [

From 5b8263471a4622615023c46cdd6b2348225db2a7 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Sat, 17 Jun 2023 23:10:36 +0200
Subject: [PATCH 10/19] COMDIRAC is already embedded in DIRAC v8, no need to
 install it separately

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e0939141..74ebd8ef 100644
--- a/README.md
+++ b/README.md
@@ -84,7 +84,7 @@ conda env config vars set X509_CERT_DIR=${CONDA_PREFIX}/etc/grid-security/certif
 # The following is needed for the environment variables, used for DIRAC configuration, to be available:
 mamba deactivate
 mamba activate nectarchain
-pip install CTADIRAC COMDIRAC
+pip install CTADIRAC
 dirac-configure
 ```
 

From 8f882eac6185d98a5d00bba3073686f9eb651d6a Mon Sep 17 00:00:00 2001
From: Halim Ashkar <halim.ashkar@cea.fr>
Date: Mon, 19 Jun 2023 10:59:43 +0200
Subject: [PATCH 11/19] upgrading DQM to CTAPIPE 0.19. (Next commit should ake
 care of flagged bad pixels and how to deal with them)

---
 src/nectarchain/dqm/charge_integration.py  | 57 +++++++++++++---------
 src/nectarchain/dqm/mean_camera_display.py | 11 +++--
 src/nectarchain/dqm/start_calib.py         |  7 ++-
 3 files changed, 44 insertions(+), 31 deletions(-)

diff --git a/src/nectarchain/dqm/charge_integration.py b/src/nectarchain/dqm/charge_integration.py
index f4c98b7c..ad60638b 100644
--- a/src/nectarchain/dqm/charge_integration.py
+++ b/src/nectarchain/dqm/charge_integration.py
@@ -45,26 +45,37 @@ def ConfigureForRun(self, path, Chan, Samp, Reader1):
         self.image_ped = []
         self.peakpos_ped = []
 
+        
+
 
     def ProcessEvent(self, evt, noped):
         #print("test", evt.r0.tel[0].waveform[0])
+        self.pixelBAD = evt.mon.tel[0].pixel_status.hardware_failing_pixels
         pixel = evt.nectarcam.tel[0].svc.pixel_ids
-        pixel21 = np.arange(0,21,1,dtype = int)
-        pixel = list(pixel)
-        pixel21 = list(pixel21)
-        pixels = np.concatenate([pixel21,pixel])
+        
+        if len(pixel) < self.Chan:
+            pixel21 = np.arange(0,self.Chan - len(pixel),1,dtype = int)
+            pixel = list(pixel)
+            pixel21 = list(pixel21)
+            pixels = np.concatenate([pixel21,pixel])
+        else:
+            pixels = pixel
 
         waveform=evt.r0.tel[0].waveform[self.k]
 
-        if noped == True: 
+        if noped:
             ped = np.mean(waveform[:, 20])
             w_noped = waveform - ped
-            image, peakpos = self.integrator(w_noped,0,np.zeros(self.Chan, dtype = int)) 
+            output = self.integrator(w_noped,0,np.zeros(self.Chan, dtype = int), self.pixelBAD)
+            image = output.image
+            peakpos = output.peak_time
             image = image[pixels]
             peakpos = peakpos[pixels]
 
         else:
-            image, peakpos = self.integrator(waveform,0,np.zeros(self.Chan, dtype = int))
+            output = self.integrator(waveform,0,np.zeros(self.Chan, dtype = int), self.pixelBAD)
+            image = output.image
+            peakpos = output.peak_time
             image = image[pixels]
             peakpos = peakpos[pixels]
 
@@ -170,9 +181,9 @@ def PlotResults(self, name, FigPath):
         # Charge integration MEAN plot
         if self.counter_evt > 0:
             fig1, disp = plt.subplots()
-            disp = CameraDisplay(self.camera)
+            disp = CameraDisplay(self.camera[~self.pixelBAD][0])
             # disp = CameraDisplay(self.subarray.tels[0].camera)
-            disp.image = self.image_all_average
+            disp.image = self.image_all_average[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
             disp.axes.text(
                 2,
@@ -198,8 +209,8 @@ def PlotResults(self, name, FigPath):
 
         if self.counter_ped > 0:
             fig2, disp = plt.subplots()
-            disp = CameraDisplay(self.camera)
-            disp.image = self.image_ped_average
+            disp = CameraDisplay(self.camera[~self.pixelBAD[0]])
+            disp.image = self.image_ped_average[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
             disp.axes.text(
                 2,
@@ -226,8 +237,8 @@ def PlotResults(self, name, FigPath):
         # Charge integration MEDIAN plot
         if self.counter_evt > 0:
             fig3, disp = plt.subplots()
-            disp = CameraDisplay(self.camera)
-            disp.image = self.image_all_median
+            disp = CameraDisplay(self.camera[~self.pixelBAD[0]])
+            disp.image = self.image_all_median[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
             disp.axes.text(
                 2,
@@ -253,8 +264,8 @@ def PlotResults(self, name, FigPath):
 
         if self.counter_ped > 0:
             fig4, disp = plt.subplots()
-            disp = CameraDisplay(self.camera)
-            disp.image = self.image_ped_median
+            disp = CameraDisplay(self.camera[~self.pixelBAD[0]])
+            disp.image = self.image_ped_median[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
             disp.axes.text(
                 2,
@@ -281,8 +292,8 @@ def PlotResults(self, name, FigPath):
         # Charge integration STD plot
         if self.counter_evt > 0:
             fig5, disp = plt.subplots()
-            disp = CameraDisplay(self.camera)
-            disp.image = self.image_all_std
+            disp = CameraDisplay(self.camera[~self.pixelBAD[0]])
+            disp.image = self.image_all_std[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
             disp.axes.text(
                 2,
@@ -308,8 +319,8 @@ def PlotResults(self, name, FigPath):
 
         if self.counter_ped > 0:
             fig6, disp = plt.subplots()
-            disp = CameraDisplay(self.camera)
-            disp.image = self.image_ped_std
+            disp = CameraDisplay(self.camera[~self.pixelBAD[0]])
+            disp.image = self.image_ped_std[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
             disp.axes.text(
                 2,
@@ -336,8 +347,8 @@ def PlotResults(self, name, FigPath):
         # Charge integration RMS plot
         if self.counter_evt > 0:
             fig7, disp = plt.subplots()
-            disp = CameraDisplay(self.camera)
-            disp.image = self.image_all_rms
+            disp = CameraDisplay(self.camera[~self.pixelBAD[0]])
+            disp.image = self.image_all_rms[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
             disp.axes.text(
                 2,
@@ -363,8 +374,8 @@ def PlotResults(self, name, FigPath):
 
         if self.counter_ped > 0:
             fig8, disp = plt.subplots()
-            disp = CameraDisplay(self.camera)
-            disp.image = self.image_ped_rms
+            disp = CameraDisplay(self.camera[~self.pixelBAD[0]])
+            disp.image = self.image_ped_rms[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
             disp.axes.text(
                 2,
diff --git a/src/nectarchain/dqm/mean_camera_display.py b/src/nectarchain/dqm/mean_camera_display.py
index 6016f14c..cc7d72c1 100644
--- a/src/nectarchain/dqm/mean_camera_display.py
+++ b/src/nectarchain/dqm/mean_camera_display.py
@@ -30,10 +30,13 @@ def ConfigureForRun(self, path, Chan, Samp, Reader1):
 
     def ProcessEvent(self, evt, noped):
         pixel = evt.nectarcam.tel[0].svc.pixel_ids
-        pixel21 = np.arange(0,21,1,dtype = int)
-        pixel = list(pixel)
-        pixel21 = list(pixel21)
-        pixels = np.concatenate([pixel21,pixel])
+        if len(pixel) < self.Chan:
+            pixel21 = np.arange(0,self.Chan - len(pixel),1,dtype = int)
+            pixel = list(pixel)
+            pixel21 = list(pixel21)
+            pixels = np.concatenate([pixel21,pixel])
+        else:
+            pixels = pixel
 
         if evt.trigger.event_type.value == 32: #count peds 
             self.counter_ped += 1
diff --git a/src/nectarchain/dqm/start_calib.py b/src/nectarchain/dqm/start_calib.py
index 6d482afe..0758be0f 100644
--- a/src/nectarchain/dqm/start_calib.py
+++ b/src/nectarchain/dqm/start_calib.py
@@ -182,8 +182,8 @@ def CreateFigFolder(name, type):
     p.ConfigureForRun(path, Chan, Samp, reader1)
 
 for i, evt in enumerate(reader):
-	for p in processors:
-		p.ProcessEvent(evt, noped)
+    for p in processors:
+        p.ProcessEvent(evt, noped)
         
 #for the rest of the event files
 for arg in args.input_files[1:]:
@@ -202,7 +202,6 @@ def CreateFigFolder(name, type):
 
 dict_num = 0
 for p in processors:
-    # True if want to compute plots, sedond true if want to save results
     NESTED_DICT[NESTED_DICT_KEYS[dict_num]] = p.GetResults()
     dict_num += 1
 
@@ -211,7 +210,7 @@ def CreateFigFolder(name, type):
 p.WriteAllResults(ResPath, NESTED_DICT) #if we want to write all results in 1 fits file we do this. 
 
 #if -plot in args it will construct the figures and save them
-if PlotFig == True:
+if PlotFig:
     for p in processors:
         processor_figure_dict, processor_figure_name_dict  = p.PlotResults(name, FigPath)
     

From d90760dc29ca731dbee7b4389d5968448c984974 Mon Sep 17 00:00:00 2001
From: Halim Ashkar <halim.ashkar@cea.fr>
Date: Mon, 19 Jun 2023 11:07:52 +0200
Subject: [PATCH 12/19] upgrading DQM to CTAPIPE 0.19 (Fixing bad pixel
 handling hsould come next)

---
 src/nectarchain/dqm/charge_integration.py  | 2 +-
 src/nectarchain/dqm/mean_camera_display.py | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/nectarchain/dqm/charge_integration.py b/src/nectarchain/dqm/charge_integration.py
index ad60638b..1c008efd 100644
--- a/src/nectarchain/dqm/charge_integration.py
+++ b/src/nectarchain/dqm/charge_integration.py
@@ -181,7 +181,7 @@ def PlotResults(self, name, FigPath):
         # Charge integration MEAN plot
         if self.counter_evt > 0:
             fig1, disp = plt.subplots()
-            disp = CameraDisplay(self.camera[~self.pixelBAD][0])
+            disp = CameraDisplay(self.camera[~self.pixelBAD[0]])
             # disp = CameraDisplay(self.subarray.tels[0].camera)
             disp.image = self.image_all_average[~self.pixelBAD[0]]
             disp.cmap = plt.cm.coolwarm
diff --git a/src/nectarchain/dqm/mean_camera_display.py b/src/nectarchain/dqm/mean_camera_display.py
index cc7d72c1..603b7a01 100644
--- a/src/nectarchain/dqm/mean_camera_display.py
+++ b/src/nectarchain/dqm/mean_camera_display.py
@@ -29,6 +29,7 @@ def ConfigureForRun(self, path, Chan, Samp, Reader1):
         self.cmap2 = "gnuplot2"
 
     def ProcessEvent(self, evt, noped):
+        self.pixelBAD = evt.mon.tel[0].pixel_status.hardware_failing_pixels
         pixel = evt.nectarcam.tel[0].svc.pixel_ids
         if len(pixel) < self.Chan:
             pixel21 = np.arange(0,self.Chan - len(pixel),1,dtype = int)
@@ -121,8 +122,8 @@ def PlotResults(self, name, FigPath):
         if self.counter_evt > 0:
             fig1, self.disp1 = plt.subplots()
             self.disp1 = CameraDisplay(
-                geometry=self.camera,
-                image=self.CameraAverage_overEvents_overSamp,
+                geometry=self.camera[~self.pixelBAD[0]],
+                image=self.CameraAverage_overEvents_overSamp[~self.pixelBAD[0]],
                 cmap=self.cmap,
             )
             self.disp1.cmap = self.cmap
@@ -144,8 +145,8 @@ def PlotResults(self, name, FigPath):
         if self.counter_ped > 0:
             fig2, self.disp2 = plt.subplots()
             self.disp2 = CameraDisplay(
-                geometry=self.camera2,
-                image=self.CameraAverage_ped_overEvents_overSamp,
+                geometry=self.camera2[~self.pixelBAD[0]],
+                image=self.CameraAverage_ped_overEvents_overSamp[~self.pixelBAD[0]],
                 cmap=self.cmap2,
             )
             self.disp2.cmap = self.cmap2

From ae1a052e204872a3b86f72b3d9a85d1542a8df06 Mon Sep 17 00:00:00 2001
From: LENAIN Jean philippe <jean-philippe.lenain@lpnhe.in2p3.fr>
Date: Tue, 20 Jun 2023 12:48:17 +0200
Subject: [PATCH 13/19] Updated notebook

---
 ...ccess NectarCAM data using DIRAC API.ipynb | 56 ++++++++++---------
 1 file changed, 30 insertions(+), 26 deletions(-)

diff --git a/notebooks/Access NectarCAM data using DIRAC API.ipynb b/notebooks/Access NectarCAM data using DIRAC API.ipynb
index 9411e540..639aa759 100644
--- a/notebooks/Access NectarCAM data using DIRAC API.ipynb	
+++ b/notebooks/Access NectarCAM data using DIRAC API.ipynb	
@@ -14,7 +14,7 @@
     "You will also need to have an active proxy for EGI, initialized e.g. with:\n",
     "\n",
     "```\n",
-    "dirac-proxy-init -U -M -g cta_nectarcam\n",
+    "dirac-proxy-init -M -g cta_nectarcam\n",
     "```\n",
     "\n",
     "You can also check whether you currently have an active proxy with the command `dirac-proxy-info`."
@@ -49,8 +49,8 @@
     {
      "data": {
       "text/plain": [
-       "\u001B[0;31mSignature:\u001B[0m \u001B[0mdirac\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mgetFile\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mlfn\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mdestDir\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;34m''\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mprintOutput\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;32mFalse\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
-       "\u001B[0;31mDocstring:\u001B[0m\n",
+       "\u001b[0;31mSignature:\u001b[0m \u001b[0mdirac\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetFile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdestDir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprintOutput\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+       "\u001b[0;31mDocstring:\u001b[0m\n",
        "Retrieve a single file or list of files from Grid storage to the current directory. lfn is the\n",
        "desired logical file name for the file, fullPath is the local path to the file and diracSE is the\n",
        "Storage Element name for the upload.  The fileGuid is optional, if not specified a GUID will be\n",
@@ -67,8 +67,8 @@
        ":param printOutput: Optional flag to print result\n",
        ":type printOutput: boolean\n",
        ":returns: S_OK,S_ERROR\n",
-       "\u001B[0;31mFile:\u001B[0m      ~/local/src/python/anaconda/envs/nectarchain-dirac/lib/python3.8/site-packages/DIRAC/Interfaces/API/Dirac.py\n",
-       "\u001B[0;31mType:\u001B[0m      method\n"
+       "\u001b[0;31mFile:\u001b[0m      ~/local/opt/conda/envs/nectarchain-ctapipe0.19/lib/python3.11/site-packages/DIRAC/Interfaces/API/Dirac.py\n",
+       "\u001b[0;31mType:\u001b[0m      method"
       ]
      },
      "metadata": {},
@@ -155,24 +155,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "id": "886e46f4-3968-4ba9-a56a-dcbcd631e1a2",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/jlenain/local/src/python/anaconda/envs/nectarchain-dirac/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%matplotlib inline\n",
     "import numpy as np\n",
     "from matplotlib import pyplot as plt\n",
     "\n",
+    "from ctapipe.coordinates import EngineeringCameraFrame\n",
     "from ctapipe.io import EventSource, EventSeeker\n",
     "from ctapipe.instrument import CameraGeometry\n",
     "from ctapipe.visualization import CameraDisplay"
@@ -180,7 +172,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 10,
    "id": "71d98271-7d6a-4ae4-9339-959d90bc6d8d",
    "metadata": {},
    "outputs": [
@@ -188,19 +180,31 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
+      "Table /tel_0/calibration is missing column time_correction for field time_correction of container <class 'ctapipe.containers.WaveformCalibrationContainer'>. It will be skipped.\n",
+      "Table /tel_0/calibration is missing column n_pe for field n_pe of container <class 'ctapipe.containers.WaveformCalibrationContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column charge_mean for field charge_mean of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column charge_median for field charge_median of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column charge_std for field charge_std of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column time_mean for field time_mean of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column time_median for field time_median of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column time_std for field time_std of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column relative_gain_median for field relative_gain_median of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column relative_gain_std for field relative_gain_std of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column relative_time_median for field relative_time_median of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column charge_median_outliers for field charge_median_outliers of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column charge_std_outliers for field charge_std_outliers of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
+      "Table /tel_0/flatfield is missing column time_median_outliers for field time_median_outliers of container <class 'ctapipe.containers.FlatFieldContainer'>. It will be skipped.\n",
       "Seeking event by iterating through events.. (potentially long process)\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -215,7 +219,7 @@
     "# Get some event, and display camera charges for the high gain channel (no time window optimization)\n",
     "evt=seeker.get_event_index(10)\n",
     "image = evt.r0.tel[0].waveform.sum(axis=2)\n",
-    "camera = CameraGeometry.from_name(\"NectarCam-003\")\n",
+    "camera = CameraGeometry.from_name(\"NectarCam-003\").transform_to(EngineeringCameraFrame())\n",
     "disp = CameraDisplay(geometry=camera, image=image[0])"
    ]
   },
@@ -230,9 +234,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "nectarchain-ctapipe0.19",
    "language": "python",
-   "name": "python3"
+   "name": "nectarchain-ctapipe0.19"
   },
   "language_info": {
    "codemirror_mode": {
@@ -244,7 +248,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.13"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

From 51fc818f29d39df62e639d4bdf07b9476e22dbcd Mon Sep 17 00:00:00 2001
From: Halim Ashkar <halim.ashkar@cea.fr>
Date: Wed, 21 Jun 2023 18:09:01 +0200
Subject: [PATCH 14/19] bug fic for mean_camera_display.py

---
 src/nectarchain/dqm/mean_camera_display.py | 64 +++++++++++++---------
 1 file changed, 37 insertions(+), 27 deletions(-)

diff --git a/src/nectarchain/dqm/mean_camera_display.py b/src/nectarchain/dqm/mean_camera_display.py
index 603b7a01..c821dd2d 100644
--- a/src/nectarchain/dqm/mean_camera_display.py
+++ b/src/nectarchain/dqm/mean_camera_display.py
@@ -28,6 +28,10 @@ def ConfigureForRun(self, path, Chan, Samp, Reader1):
         self.cmap = "gnuplot2"
         self.cmap2 = "gnuplot2"
 
+        self.CameraAverage = []
+        self.CameraAverage_ped = []
+
+
     def ProcessEvent(self, evt, noped):
         self.pixelBAD = evt.mon.tel[0].pixel_status.hardware_failing_pixels
         pixel = evt.nectarcam.tel[0].svc.pixel_ids
@@ -41,28 +45,31 @@ def ProcessEvent(self, evt, noped):
 
         if evt.trigger.event_type.value == 32: #count peds 
             self.counter_ped += 1
-        else:
-            self.counter_evt += 1
+            self.CameraAverage_ped1 = (
+                evt.r0.tel[0].waveform[self.k].sum(axis=1))
+            self.CameraAverage_ped.append(self.CameraAverage_ped1[pixels])
 
-        if evt.trigger.event_type.value == 32:  # only peds now
-            self.CameraAverage_ped += (
-                evt.r0.tel[0].waveform[self.k].sum(axis=1)
-            )  # fill channels one by one and sum them for peds only
-            self.CameraAverage_ped = self.CameraAverage_ped[pixels]
         else:
-            self.CameraAverage += (
-                evt.r0.tel[0].waveform[self.k].sum(axis=1)
-            )  # fill channels one by one and sum them
-            self.CameraAverage = self.CameraAverage[pixels]
+            self.counter_evt += 1
+            self.CameraAverage1 = (
+                evt.r0.tel[0].waveform[self.k].sum(axis=1))
+            self.CameraAverage.append(self.CameraAverage1[pixels])
+            
         return None
 
     def FinishRun(self):
-        self.CameraAverage_overEvents = self.CameraAverage / self.counter_evt
-        self.CameraAverage_overEvents_overSamp = (
-            self.CameraAverage_overEvents / self.Samp
-        )
+        if self.counter_evt > 0:
+            self.CameraAverage = np.array(self.CameraAverage)
+            self.CameraAverage = self.CameraAverage.sum(axis = 0)
+            self.CameraAverage_overEvents = (self.CameraAverage / self.counter_evt)
+        
+            self.CameraAverage_overEvents_overSamp = (
+                self.CameraAverage_overEvents / self.Samp
+            )
 
         if self.counter_ped > 0:
+            self.CameraAverage_ped = np.array(self.CameraAverage_ped)
+            self.CameraAverage_ped = self.CameraAverage_ped.sum(axis = 0)
             self.CameraAverage_ped_overEvents = (
                 self.CameraAverage_ped / self.counter_ped
             )
@@ -76,12 +83,14 @@ def GetResults(self):
 
         # ASSIGN RESUTLS TO DICT
         if self.k == 0:
-            # self.MeanCameraDisplay_Results_Dict[
-            # "CAMERA-AVERAGE-OverEVENTS-HIGH-GAIN"
-            # ]  = self.CameraAverage_overEvents
-            self.MeanCameraDisplay_Results_Dict[
-                "CAMERA-AVERAGE-PHY-OverEVENTS-OverSamp-HIGH-GAIN"
-            ] = self.CameraAverage_overEvents_overSamp
+
+            if self.counter_evt > 0:
+                # self.MeanCameraDisplay_Results_Dict[
+                # "CAMERA-AVERAGE-OverEVENTS-HIGH-GAIN"
+                # ]  = self.CameraAverage_overEvents
+                self.MeanCameraDisplay_Results_Dict[
+                    "CAMERA-AVERAGE-PHY-OverEVENTS-OverSamp-HIGH-GAIN"
+                ] = self.CameraAverage_overEvents_overSamp
 
             if self.counter_ped > 0:
                 # self.MeanCameraDisplay_Results_Dict[
@@ -92,12 +101,13 @@ def GetResults(self):
                 ] = self.CameraAverage_ped_overEvents_overSamp
 
         if self.k == 1:
-            # self.MeanCameraDisplay_Results_Dict[
-            # "CAMERA-AVERAGE-OverEVENTS-LOW-GAIN"
-            # ]  = self.CameraAverage_overEvents
-            self.MeanCameraDisplay_Results_Dict[
-                "CAMERA-AVERAGE-PHY-OverEVENTS-OverSamp-LOW-GAIN"
-            ] = self.CameraAverage_overEvents_overSamp
+            if self.counter_evt > 0:
+                # self.MeanCameraDisplay_Results_Dict[
+                # "CAMERA-AVERAGE-OverEVENTS-LOW-GAIN"
+                # ]  = self.CameraAverage_overEvents
+                self.MeanCameraDisplay_Results_Dict[
+                    "CAMERA-AVERAGE-PHY-OverEVENTS-OverSamp-LOW-GAIN"
+                ] = self.CameraAverage_overEvents_overSamp
 
             if self.counter_ped > 0:
                 # self.MeanCameraDisplay_Results_Dict[

From 8f161702dd722b23763534fe2029585b73e08bd2 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Thu, 6 Jul 2023 12:15:43 +0200
Subject: [PATCH 15/19] Change the way the python version is specified,
 otherwise CI tests fail in testing the code for different python versions.

---
 environment.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/environment.yml b/environment.yml
index 2b38d9af..5d0bdc6f 100644
--- a/environment.yml
+++ b/environment.yml
@@ -3,7 +3,7 @@ channels:
   - default
   - conda-forge
 dependencies:
-  - python>=3.8 # nail the python version, so conda does not try upgrading / downgrading
+  - python=3.11
   - ctapipe=0.19.1
   - ctapipe-io-nectarcam
   - jupyterlab

From 9b4fc9e62c4223124aad3424f1d1ed546446d0b8 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Thu, 6 Jul 2023 12:19:06 +0200
Subject: [PATCH 16/19] Python 3.10 interpreted as 3.1 in CI

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2ec1a7c4..8f0b6849 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -31,7 +31,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.8, 3.9, 3.10, 3.11]
+        python-version: [3.8, 3.9, "3.10", 3.11]
         ctapipe-version: [v0.19.1]
 
     defaults:

From 5c055257c97c6d3bc5217f4e10348977f386b9c0 Mon Sep 17 00:00:00 2001
From: "guillaume.grolleron" <ggroller@lpnhe.in2p3.fr>
Date: Wed, 12 Jul 2023 11:02:14 +0200
Subject: [PATCH 17/19] clean commit history : -update SPE fit parameters
 initialization following updates of the ctapipe extractors -improve the
 limits of generated charge histogram plots

---
 .../NectarGain/SPEfit/NectarGainSPE.py        | 21 ++++++++++++-------
 .../SPEfit/NectarGainSPE_singlerun.py         | 20 ++++++++++--------
 2 files changed, 24 insertions(+), 17 deletions(-)

diff --git a/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE.py b/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE.py
index a124afc4..245ec50d 100644
--- a/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE.py
+++ b/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE.py
@@ -30,6 +30,9 @@
 
 class NectarGainSPE(ABC) :
     _Ncall = 4000000
+    _Windows_lenght = 40
+    _Order = 2
+
     def __init__(self) :
         #set parameters value for fit
         self.__parameters = Parameters()
@@ -104,8 +107,8 @@ def _get_mean_gaussian_fit(charge_in, histo_in ,extension = ""):
         charge = charge_in.data[~histo_in.mask]
         histo = histo_in.data[~histo_in.mask]
 
-        windows_lenght = 80
-        order = 2
+        windows_lenght = NectarGainSPE._Windows_lenght
+        order = NectarGainSPE._Order
         histo_smoothed = savgol_filter(histo, windows_lenght, order)
 
         peaks = find_peaks(histo_smoothed,10)
@@ -126,15 +129,16 @@ def _get_mean_gaussian_fit(charge_in, histo_in ,extension = ""):
 
         if log.getEffectiveLevel() == logging.DEBUG :
             log.debug('plotting figures with prefit parameters computation') 
-            fig,ax = plt.subplots(1,1,figsize = (8,8))
+            fig,ax = plt.subplots(1,1,figsize = (5,5))
             ax.errorbar(charge,histo,np.sqrt(histo),zorder=0,fmt=".",label = "data")
             ax.plot(charge,histo_smoothed,label = f'smoothed data with savgol filter (windows lenght : {windows_lenght}, order : {order})')
             ax.plot(charge,weight_gaussian(charge,coeff_mean[0],coeff_mean[1],coeff_mean[2]),label = 'gaussian fit of the SPE')
             ax.vlines(coeff_mean[1],0,peak_value,label = f'mean initial value = {coeff_mean[1] - coeff[1]:.0f}',color = "red")
             ax.add_patch(Rectangle((coeff_mean[1]-coeff_mean[2], 0), 2 * coeff_mean[2], peak_value_mean,fc=to_rgba('red', 0.5)))
+            ax.set_xlim([peak_pos - 500,None])
             ax.set_xlabel("Charge (ADC)", size=15)
             ax.set_ylabel("Events", size=15)
-            ax.legend(fontsize=15)
+            ax.legend(fontsize=7)
             os.makedirs(f"{os.environ.get('NECTARCHAIN_LOG')}/{os.getpid()}/figures/",exist_ok=True)
             fig.savefig(f"{os.environ.get('NECTARCHAIN_LOG')}/{os.getpid()}/figures/initialization_mean_pixel{extension}_{os.getpid()}.pdf")
             fig.clf()
@@ -149,8 +153,8 @@ def _get_pedestal_gaussian_fit(charge_in, histo_in ,extension = "") :
         charge = charge_in.data[~histo_in.mask]
         histo = histo_in.data[~histo_in.mask]
 
-        windows_lenght = 80
-        order = 2
+        windows_lenght = NectarGainSPE._Windows_lenght
+        order = NectarGainSPE._Order
         histo_smoothed = savgol_filter(histo, windows_lenght, order)
 
         peaks = find_peaks(histo_smoothed,10)
@@ -161,15 +165,16 @@ def _get_pedestal_gaussian_fit(charge_in, histo_in ,extension = "") :
 
         if log.getEffectiveLevel() == logging.DEBUG :
             log.debug('plotting figures with prefit parameters computation') 
-            fig,ax = plt.subplots(1,1,figsize = (8,8))
+            fig,ax = plt.subplots(1,1,figsize = (5,5))
             ax.errorbar(charge,histo,np.sqrt(histo),zorder=0,fmt=".",label = "data")
             ax.plot(charge,histo_smoothed,label = f'smoothed data with savgol filter (windows lenght : {windows_lenght}, order : {order})')
             ax.plot(charge,weight_gaussian(charge,coeff[0],coeff[1],coeff[2]),label = 'gaussian fit of the pedestal, left tail only')
+            ax.set_xlim([peak_pos - 500,None])
             ax.vlines(coeff[1],0,peak_value,label = f'pedestal initial value = {coeff[1]:.0f}',color = 'red')
             ax.add_patch(Rectangle((coeff[1]-coeff[2], 0), 2 * coeff[2], peak_value,fc=to_rgba('red', 0.5)))
             ax.set_xlabel("Charge (ADC)", size=15)
             ax.set_ylabel("Events", size=15)
-            ax.legend(fontsize=15)
+            ax.legend(fontsize=7)
             os.makedirs(f"{os.environ.get('NECTARCHAIN_LOG')}/{os.getpid()}/figures/",exist_ok=True)
             fig.savefig(f"{os.environ.get('NECTARCHAIN_LOG')}/{os.getpid()}/figures/initialization_pedestal_pixel{extension}_{os.getpid()}.pdf")
             fig.clf()
diff --git a/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py b/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py
index 17ea3ffc..05aae793 100644
--- a/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py
+++ b/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py
@@ -4,7 +4,7 @@
 from iminuit import Minuit
 import random
 import astropy.units as u
-from astropy.table import QTable,Column,MaskedColumn
+from astropy.table import Table,QTable,Column,MaskedColumn
 import yaml
 import os
 from datetime import date
@@ -457,17 +457,18 @@ def _run_obs_static(cls,it : int, funct,parameters : Parameters, pixels_id : int
 
 
             if kwargs.get('figpath',0) != 0 :
-                fig,ax = plt.subplots(1,1,figsize=(8, 6))
+                fig,ax = plt.subplots(1,1,figsize=(8, 8))
                 ax.errorbar(charge,histo,np.sqrt(histo),zorder=0,fmt=".",label = "data")
                 ax.plot(charge,
                     np.trapz(histo,charge)*MPE2(charge,parameters['pp'].value, parameters['resolution'].value, parameters['mean'].value, parameters['n'].value, parameters['pedestal'].value, parameters['pedestalWidth'].value, parameters['luminosity'].value),
                     zorder=1,
                     linewidth=2,
-                    label = f"SPE model fit \n gain : {gain[0] - gain[1]:.2f} < {gain[0]:.2f} < {gain[0] + gain[2]:.2f} ADC/pe, pvalue = {Statistics.chi2_pvalue(ndof,fit.fval)},\n likelihood = {fit.fval:.2f}")
+                    label = f"SPE model fit \n gain : {gain[0] - gain[1]:.2f} < {gain[0]:.2f} < {gain[0] + gain[2]:.2f} ADC/pe,\n pvalue = {Statistics.chi2_pvalue(ndof,fit.fval)},\n likelihood = {fit.fval:.2f}")
                 ax.set_xlabel("Charge (ADC)", size=15)
                 ax.set_ylabel("Events", size=15)
                 ax.set_title(f"SPE fit pixel {it} with pixel_id : {pixels_id}")
-                ax.legend(fontsize=15)
+                ax.set_xlim([parameters['pedestal'].value - 6 * parameters['pedestalWidth'].value, None])
+                ax.legend(fontsize=18)
                 os.makedirs(kwargs.get('figpath'),exist_ok = True)
                 fig.savefig(f"{kwargs.get('figpath')}/fit_SPE_pixel{pixels_id}.pdf")
                 fig.clf()
@@ -503,17 +504,18 @@ def _run_obs(self,pixel,prescan = False,**kwargs) :
 
 
             if kwargs.get('figpath',0) != 0 :
-                fig,ax = plt.subplots(1,1,figsize=(8, 6))
+                fig,ax = plt.subplots(1,1,figsize=(8, 8))
                 ax.errorbar(self.charge[pixel],self.histo[pixel],np.sqrt(self.histo[pixel]),zorder=0,fmt=".",label = "data")
                 ax.plot(self.charge[pixel],
                     np.trapz(self.histo[pixel],self.charge[pixel])*MPE2(self.charge[pixel],self.__pp.value,self.__resolution.value,self.__mean.value,self.__n.value,self.pedestal.value,self.__pedestalWidth.value,self.__luminosity.value),
                     zorder=1,
                     linewidth=2,
-                    label = f"SPE model fit \n gain : {self.__gain[pixel,0] - self.__gain[pixel,1]:.2f} < {self.__gain[pixel,0]:.2f} < {self.__gain[pixel,0] + self.__gain[pixel,2]:.2f} ADC/pe, pvalue = {Statistics.chi2_pvalue(ndof,fit.fval)},\n likelihood = {fit.fval:.2f}")
+                    label = f"SPE model fit \n gain : {self.__gain[pixel,0] - self.__gain[pixel,1]:.2f} < {self.__gain[pixel,0]:.2f} < {self.__gain[pixel,0] + self.__gain[pixel,2]:.2f} ADC/pe,\n pvalue = {Statistics.chi2_pvalue(ndof,fit.fval)},\n likelihood = {fit.fval:.2f}")
                 ax.set_xlabel("Charge (ADC)", size=15)
                 ax.set_ylabel("Events", size=15)
                 ax.set_title(f"SPE fit pixel : {pixel} (pixel id : {self.pixels_id[pixel]})")
-                ax.legend(fontsize=15)
+                ax.set_xlim([self.pedestal.value - 6 * self.pedestalWidth.value, None])
+                ax.legend(fontsize=18)
                 os.makedirs(kwargs.get('figpath'),exist_ok = True)
                 fig.savefig(f"{kwargs.get('figpath')}/fit_SPE_pixel{self.pixels_id[pixel]}.pdf")
                 fig.clf()
@@ -571,7 +573,7 @@ def _update_parameters_prefit_static(cls,it : int, parameters : Parameters, char
         log.debug(f"pedestalWidth updated : {pedestalWidth}")
         try : 
             coeff,var_matrix =  NectarGainSPE._get_mean_gaussian_fit(charge,histo,f'{it}_nominal')
-            if coeff[1] - pedestal.value < 0 : raise Exception("mean gaussian fit not good")
+            if (coeff[1] - pedestal.value < 0) or ((coeff[1] - coeff[2]) - pedestal.max < 0) : raise Exception("mean gaussian fit not good")
             mean = parameters['mean']
             mean.value = coeff[1] - pedestal.value
             mean.min = (coeff[1] - coeff[2]) - pedestal.max
@@ -785,7 +787,7 @@ def run(self,pixel : int = None,multiproc = False, **kwargs):
         super().run(pixel,multiproc,**kwargs)
 
     def _run_obs(self,pixel,prescan = False,**kwargs) : 
-        if self.__nectarGainSPEresult[pixel]['is_valid'].value : 
+        if self.__nectarGainSPEresult[pixel]['is_valid'] : 
             kwargs['pixel_id'] = self.pixels_id[pixel]
             super()._run_obs(pixel,prescan,**kwargs)
         else :

From a75d4c976da3fce83409c6c0b6364bfd415bd7eb Mon Sep 17 00:00:00 2001
From: "guillaume.grolleron" <ggroller@lpnhe.in2p3.fr>
Date: Wed, 12 Jul 2023 14:49:15 +0200
Subject: [PATCH 18/19] remove useless imports

---
 .../calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py b/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py
index 05aae793..a34e0205 100644
--- a/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py
+++ b/src/nectarchain/calibration/NectarGain/SPEfit/NectarGainSPE_singlerun.py
@@ -4,7 +4,7 @@
 from iminuit import Minuit
 import random
 import astropy.units as u
-from astropy.table import Table,QTable,Column,MaskedColumn
+from astropy.table import QTable,Column,MaskedColumn
 import yaml
 import os
 from datetime import date

From f9314c1546897fb1ed4801e5296e27b19781960a Mon Sep 17 00:00:00 2001
From: Jean-Philippe Lenain <jlenain@in2p3.fr>
Date: Wed, 12 Jul 2023 15:40:59 +0200
Subject: [PATCH 19/19] Revert changes in DQM which actually belong to #63

---
 src/nectarchain/dqm/charge_integration.py  | 12 ++++--------
 src/nectarchain/dqm/mean_camera_display.py | 11 ++++-------
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/src/nectarchain/dqm/charge_integration.py b/src/nectarchain/dqm/charge_integration.py
index 1c008efd..38f8e37e 100644
--- a/src/nectarchain/dqm/charge_integration.py
+++ b/src/nectarchain/dqm/charge_integration.py
@@ -52,14 +52,10 @@ def ProcessEvent(self, evt, noped):
         #print("test", evt.r0.tel[0].waveform[0])
         self.pixelBAD = evt.mon.tel[0].pixel_status.hardware_failing_pixels
         pixel = evt.nectarcam.tel[0].svc.pixel_ids
-        
-        if len(pixel) < self.Chan:
-            pixel21 = np.arange(0,self.Chan - len(pixel),1,dtype = int)
-            pixel = list(pixel)
-            pixel21 = list(pixel21)
-            pixels = np.concatenate([pixel21,pixel])
-        else:
-            pixels = pixel
+        pixel21 = np.arange(0, 21, 1, dtype=int)
+        pixel = list(pixel)
+        pixel21 = list(pixel21)
+        pixels = np.concatenate([pixel21, pixel])
 
         waveform=evt.r0.tel[0].waveform[self.k]
 
diff --git a/src/nectarchain/dqm/mean_camera_display.py b/src/nectarchain/dqm/mean_camera_display.py
index c821dd2d..0cfcf0f0 100644
--- a/src/nectarchain/dqm/mean_camera_display.py
+++ b/src/nectarchain/dqm/mean_camera_display.py
@@ -35,13 +35,10 @@ def ConfigureForRun(self, path, Chan, Samp, Reader1):
     def ProcessEvent(self, evt, noped):
         self.pixelBAD = evt.mon.tel[0].pixel_status.hardware_failing_pixels
         pixel = evt.nectarcam.tel[0].svc.pixel_ids
-        if len(pixel) < self.Chan:
-            pixel21 = np.arange(0,self.Chan - len(pixel),1,dtype = int)
-            pixel = list(pixel)
-            pixel21 = list(pixel21)
-            pixels = np.concatenate([pixel21,pixel])
-        else:
-            pixels = pixel
+        pixel21 = np.arange(0,21,1,dtype = int)
+        pixel = list(pixel)
+        pixel21 = list(pixel21)
+        pixels = np.concatenate([pixel21,pixel])
 
         if evt.trigger.event_type.value == 32: #count peds 
             self.counter_ped += 1