Changeset 3624 for trunk/MagicSoft

Timestamp:

04/01/04 14:52:32 (21 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars

Files:

• Changelog (modified) (1 diff)
• macros/calibration.C (modified) (2 diffs)
• manalysis/MGeomApply.cc (modified) (1 diff)
• mcalib/MCalibrationChargeCalc.cc (modified) (2 diffs)
• mcalib/MCalibrationChargeCam.cc (modified) (11 diffs)
• mcalib/MCalibrationChargeCam.h (modified) (4 diffs)
• mcalib/MHCalibrationChargeCam.cc (modified) (25 diffs)
• mcalib/MHCalibrationChargeCam.h (modified) (4 diffs)

trunk/MagicSoft/Mars/Changelog

@@ -19 +19 @@
                                                  -*-*- END OF LINE -*-*-
 
+
+ 2004/04/01: Markus Gaug
+
+   * mcalib/MHCalibrationChargeCam.[h,cc]
+   * mcalib/MCalibrationChargeCam.[h,cc]
+   * mcalib/MCalibrationChargeCalc.cc
+   * manalysis/MGeomApply.cc
+     - add average pixels per sector
 
  2004/03/31: Markus Gaug

trunk/MagicSoft/Mars/macros/calibration.C

@@ -27 +27 @@
 {
 
-  const TString inpath = "/home/rootdata/BlindPixel/";
+  //  const TString inpath = "/mnt/Data/rootdata/CrabNebula/2004_01_27/";
+  const TString inpath = "/mnt/Data/rootdata/Miscellaneous/2004_03_03/";
+  //  const TString inpath = "/home/rootdata/BlindPixel/";
 
   MRunIter pruns;
   MRunIter cruns;
 
-  pruns.AddRun(22007,inpath);
-  cruns.AddRun(22006,inpath);
+  pruns.AddRun(20132,inpath);
+  cruns.AddRun(20134,inpath);
+  //  cruns.AddRun(16774,inpath);
 
   gStyle->SetOptStat(1111);
@@ -204 +207 @@
   //
   //  histblind.DrawClone("all");
-  //  histcharge[555].DrawClone("all");
+  //  histcharge[400].DrawClone("all");
   //  histcharge(5).DrawClone("all");
   //  histtime[5].DrawClone("fourierevents");
-  
+  for (Int_t aidx=0;aidx<2;aidx++)
+    {
+      histcharge.GetAverageHiGainArea(aidx).DrawClone("all");
+      histcharge.GetAverageLoGainArea(aidx).DrawClone("all");
+    }
+  
+  for (Int_t sector=1;sector<7;sector++)
+    {
+      histcharge.GetAverageHiGainSector(sector).DrawClone("all");
+      histcharge.GetAverageLoGainSector(sector).DrawClone("all");
+    }
+  
+
   // Create histograms to display
   MHCamera disp1  (geomcam, "Cal;Charge",               "Fitted Mean Charges");

trunk/MagicSoft/Mars/manalysis/MGeomApply.cc

@@ -138 +138 @@
       {
         cal->InitSize(cam->GetNumPixels());
-        cal->InitAverageSize(cam->GetNumAreas());
+        cal->InitAverageAreas(cam->GetNumAreas());
+        cal->InitAverageSectors(cam->GetNumSectors());
       }
     

trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc

@@ -642 +642 @@
     {
 
-      FinalizeAvPedestals(fCam->GetAveragePix(aidx), avinnerped, avinnerprms,avinnernum);
-      FinalizeCharges(fCam->GetAveragePix(aidx),fCam->GetAverageBadPix(aidx));
+      FinalizeAvPedestals(fCam->GetAverageArea(aidx), avinnerped, avinnerprms,avinnernum);
+      FinalizeCharges(fCam->GetAverageArea(aidx),fCam->GetAverageBadArea(aidx));
+    }
+  
+  for (UInt_t sector=0; sector<fGeom->GetNumSectors(); sector++)
+    {
+
+      FinalizeAvPedestals(fCam->GetAverageSector(sector), avinnerped, avinnerprms,avinnernum);
+      FinalizeCharges(fCam->GetAverageSector(sector),fCam->GetAverageBadSector(sector));
     }
   
@@ -709 +716 @@
 
   fCam->SetReadyToSave();
+  
+  *fLog << err << "Sectors: " << fGeom->GetNumSectors() << endl;
 
   *fLog << inf << endl;

trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.cc

@@ -151 +151 @@
 
     fPixels           = new TClonesArray("MCalibrationChargePix",1);
-    fAveragePixels    = new TClonesArray("MCalibrationChargePix",1);
-    fAverageBadPixels = new TClonesArray("MBadPixelsPix",1);
+    fAverageAreas     = new TClonesArray("MCalibrationChargePix",1);
+    fAverageBadAreas  = new TClonesArray("MBadPixelsPix",1);
+    fAverageSectors     = new TClonesArray("MCalibrationChargePix",1);
+    fAverageBadSectors  = new TClonesArray("MBadPixelsPix",1);
 
     Clear();
@@ -175 +177 @@
   // 
   delete fPixels;
-  delete fAveragePixels;
-  delete fAverageBadPixels;
+  delete fAverageAreas;
+  delete fAverageBadAreas;
+  delete fAverageSectors;
+  delete fAverageBadSectors;
+  
   
   if (fOffsets)
@@ -200 +205 @@
 }
 
-void MCalibrationChargeCam::InitAverageSize(const UInt_t i)
-{
-  fAveragePixels->ExpandCreate(i);
-  fAverageBadPixels->ExpandCreate(i);
+void MCalibrationChargeCam::InitAverageAreas(const UInt_t i)
+{
+  fAverageAreas->ExpandCreate(i);
+  fAverageBadAreas->ExpandCreate(i);
+}
+
+void MCalibrationChargeCam::InitAverageSectors(const UInt_t i)
+{
+  fAverageSectors->ExpandCreate(i);
+  fAverageBadSectors->ExpandCreate(i);
 }
 
@@ -220 +231 @@
 }
 
-Int_t MCalibrationChargeCam::GetAverageSize() const
-{
-  return fAveragePixels->GetEntriesFast();
+Int_t MCalibrationChargeCam::GetAverageAreas() const
+{
+  return fAverageAreas->GetEntriesFast();
+}
+
+Int_t MCalibrationChargeCam::GetAverageSectors() const
+{
+  return fAverageSectors->GetEntriesFast();
 }
 
@@ -248 +264 @@
 // Get i-th average pixel (area number)
 //
-MCalibrationChargePix &MCalibrationChargeCam::GetAveragePix(UInt_t i)
-{
-  return *static_cast<MCalibrationChargePix*>(fAveragePixels->UncheckedAt(i));
+MCalibrationChargePix &MCalibrationChargeCam::GetAverageArea(UInt_t i)
+{
+  return *static_cast<MCalibrationChargePix*>(fAverageAreas->UncheckedAt(i));
 }
 
@@ -257 +273 @@
 // Get i-th average pixel (area number)
 //
-const MCalibrationChargePix &MCalibrationChargeCam::GetAveragePix(UInt_t i) const 
-{
-  return *static_cast<MCalibrationChargePix*>(fAveragePixels->UncheckedAt(i));
+const MCalibrationChargePix &MCalibrationChargeCam::GetAverageArea(UInt_t i) const 
+{
+  return *static_cast<MCalibrationChargePix*>(fAverageAreas->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th average pixel (sector number)
+//
+MCalibrationChargePix &MCalibrationChargeCam::GetAverageSector(UInt_t i)
+{
+  return *static_cast<MCalibrationChargePix*>(fAverageSectors->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th average pixel (sector number)
+//
+const MCalibrationChargePix &MCalibrationChargeCam::GetAverageSector(UInt_t i) const 
+{
+  return *static_cast<MCalibrationChargePix*>(fAverageSectors->UncheckedAt(i));
 }
 
@@ -266 +300 @@
 // Get i-th average pixel (area number)
 //
-MBadPixelsPix &MCalibrationChargeCam::GetAverageBadPix(UInt_t i)
-{
-  return *static_cast<MBadPixelsPix*>(fAverageBadPixels->UncheckedAt(i));
+MBadPixelsPix &MCalibrationChargeCam::GetAverageBadArea(UInt_t i)
+{
+  return *static_cast<MBadPixelsPix*>(fAverageBadAreas->UncheckedAt(i));
 }
 
@@ -275 +309 @@
 // Get i-th average pixel (area number)
 //
-const MBadPixelsPix &MCalibrationChargeCam::GetAverageBadPix(UInt_t i) const 
-{
-  return *static_cast<MBadPixelsPix*>(fAverageBadPixels->UncheckedAt(i));
+const MBadPixelsPix &MCalibrationChargeCam::GetAverageBadArea(UInt_t i) const 
+{
+  return *static_cast<MBadPixelsPix*>(fAverageBadAreas->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th average pixel (sector number)
+//
+MBadPixelsPix &MCalibrationChargeCam::GetAverageBadSector(UInt_t i)
+{
+  return *static_cast<MBadPixelsPix*>(fAverageBadSectors->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th average pixel (sector number)
+//
+const MBadPixelsPix &MCalibrationChargeCam::GetAverageBadSector(UInt_t i) const 
+{
+  return *static_cast<MBadPixelsPix*>(fAverageBadSectors->UncheckedAt(i));
 }
 
@@ -291 +343 @@
   // another ForEach does not compile, thus have to do the loop ourselves:
   //
-  for (Int_t i=0;i<GetAverageSize();i++)
-    {
-      fAveragePixels[i].Clear();
-      fAverageBadPixels[i].Clear();
+  for (Int_t i=0;i<GetAverageAreas();i++)
+    {
+      fAverageAreas[i].Clear();
+      fAverageBadAreas[i].Clear();
+    }
+
+  //
+  // another ForEach does not compile, thus have to do the loop ourselves:
+  //
+  for (Int_t i=0;i<GetAverageSectors();i++)
+    {
+      fAverageSectors[i].Clear();
+      fAverageBadSectors[i].Clear();
     }
   
@@ -418 +479 @@
   *fLog << endl;
 
-  TIter Next5(fAveragePixels);
+  TIter Next5(fAverageAreas);
   while ((pix=(MCalibrationChargePix*)Next5()))
   {
-    *fLog << all << "Average Pix:" 
+    *fLog << all << "Average Area:" 
           << "   Ped.  Rms: "            << pix->GetPedRms()        << " +- " << pix->GetPedRmsErr() 
           << "   Mean signal: "          << pix->GetMeanCharge()    << " +- " << pix->GetMeanChargeErr() 
@@ -429 +490 @@
           << endl;
   }
+
+  TIter Next6(fAverageSectors);
+  while ((pix=(MCalibrationChargePix*)Next5()))
+  {
+    *fLog << all << "Average Sector:" 
+          << "   Ped.  Rms: "            << pix->GetPedRms()        << " +- " << pix->GetPedRmsErr() 
+          << "   Mean signal: "          << pix->GetMeanCharge()    << " +- " << pix->GetMeanChargeErr() 
+          << "   Sigma signal: "         << pix->GetSigmaCharge()    << " +- "<< pix->GetSigmaChargeErr() 
+          << "   Reduced Sigma: "        << pix->GetRSigmaCharge() 
+          << "   Nr Phe's: "             << pix->GetPheFFactorMethod() 
+          << endl;
+  }
+
 }
 

trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.h

@@ -33 +33 @@
   
   TClonesArray *fPixels;             //-> Array of MCalibrationChargePix, one per pixel
-  TClonesArray *fAveragePixels;      //-> Array of MCalibrationChargePix, one per pixel area
-  TClonesArray *fAverageBadPixels;   //-> Array of MBadPixelsPix, one per pixel area
+  TClonesArray *fAverageAreas;       //-> Array of MCalibrationChargePix, one per pixel area
+  TClonesArray *fAverageSectors;     //-> Array of MCalibrationChargePix, one per camera sector
+  TClonesArray *fAverageBadAreas;    //-> Array of MBadPixelsPix, one per pixel area
+  TClonesArray *fAverageBadSectors;  //-> Array of MBadPixelsPix, one per camera sector
   
   TH1D* fOffsets;                    //! 
@@ -62 +64 @@
   void Clear(    Option_t *o="" );
   void InitSize( const UInt_t i );
-  void InitAverageSize( const UInt_t i );
+  void InitAverageAreas(  const UInt_t i );
+  void InitAverageSectors( const UInt_t i );
 
   // Setters   
@@ -77 +80 @@
   // Getters
   Int_t   GetSize()               const;
-  Int_t   GetAverageSize()        const;  
+  Int_t   GetAverageAreas()       const;
+  Int_t   GetAverageSectors()     const;  
 
   Bool_t  GetConversionFactorFFactor(    Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
@@ -101 +105 @@
   const MCalibrationChargePix &operator[](UInt_t i) const;
 
-  MCalibrationChargePix &GetAveragePix(UInt_t i);
-  const MCalibrationChargePix &GetAveragePix(UInt_t i) const;
+  MCalibrationChargePix &GetAverageArea(UInt_t i);
+  const MCalibrationChargePix &GetAverageArea(UInt_t i) const;
 
-  MBadPixelsPix &GetAverageBadPix(UInt_t i);
-  const MBadPixelsPix &GetAverageBadPix(UInt_t i) const;
+  MBadPixelsPix &GetAverageBadArea(UInt_t i);
+  const MBadPixelsPix &GetAverageBadArea(UInt_t i) const;
+
+  MCalibrationChargePix &GetAverageSector(UInt_t i);
+  const MCalibrationChargePix &GetAverageSector(UInt_t i) const;
+
+  MBadPixelsPix &GetAverageBadSector(UInt_t i);
+  const MBadPixelsPix &GetAverageBadSector(UInt_t i) const;
 
   // Prints

trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeCam.cc

@@ -112 +112 @@
     fLoGainArray->SetOwner();
 
-    fAverageHiGainArray = new TObjArray;
-    fAverageHiGainArray->SetOwner();
-
-    fAverageLoGainArray = new TObjArray;
-    fAverageLoGainArray->SetOwner();
+    fAverageHiGainAreas = new TObjArray;
+    fAverageHiGainAreas->SetOwner();
+
+    fAverageLoGainAreas = new TObjArray;
+    fAverageLoGainAreas->SetOwner();
+
+    fAverageHiGainSectors = new TObjArray;
+    fAverageHiGainSectors->SetOwner();
+
+    fAverageLoGainSectors = new TObjArray;
+    fAverageLoGainSectors->SetOwner();
 
     SetNumHiGainSaturationLimit();
@@ -133 +139 @@
   delete fLoGainArray;
 
-  delete fAverageHiGainArray;
-  delete fAverageLoGainArray;
+  delete fAverageHiGainAreas;
+  delete fAverageLoGainAreas;
+
+  delete fAverageHiGainSectors;
+  delete fAverageLoGainSectors;
 }
 
@@ -177 +186 @@
 // Get i-th pixel (pixel number)
 //
-MHCalibrationChargeHiGainPix &MHCalibrationChargeCam::GetAverageHiGainPix(UInt_t i)
-{
-  return *static_cast<MHCalibrationChargeHiGainPix*>(fAverageHiGainArray->UncheckedAt(i));
-}
-
-// --------------------------------------------------------------------------
-//
-// Get i-th pixel (pixel number)
-//
-const MHCalibrationChargeHiGainPix &MHCalibrationChargeCam::GetAverageHiGainPix(UInt_t i) const
-{
-  return *static_cast<MHCalibrationChargeHiGainPix*>(fAverageHiGainArray->UncheckedAt(i));
-}
-
-// --------------------------------------------------------------------------
-//
-// Get i-th pixel (pixel number)
-//
-MHCalibrationChargeLoGainPix &MHCalibrationChargeCam::GetAverageLoGainPix(UInt_t i)
-{
-  return *static_cast<MHCalibrationChargeLoGainPix*>(fAverageLoGainArray->UncheckedAt(i));
-}
-
-// --------------------------------------------------------------------------
-//
-// Get i-th pixel (pixel number)
-//
-const MHCalibrationChargeLoGainPix &MHCalibrationChargeCam::GetAverageLoGainPix(UInt_t i) const
-{
-  return *static_cast<MHCalibrationChargeLoGainPix*>(fAverageLoGainArray->UncheckedAt(i));
+MHCalibrationChargeHiGainPix &MHCalibrationChargeCam::GetAverageHiGainArea(UInt_t i)
+{
+  return *static_cast<MHCalibrationChargeHiGainPix*>(fAverageHiGainAreas->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th pixel (pixel number)
+//
+const MHCalibrationChargeHiGainPix &MHCalibrationChargeCam::GetAverageHiGainArea(UInt_t i) const
+{
+  return *static_cast<MHCalibrationChargeHiGainPix*>(fAverageHiGainAreas->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th pixel (pixel number)
+//
+MHCalibrationChargeLoGainPix &MHCalibrationChargeCam::GetAverageLoGainArea(UInt_t i)
+{
+  return *static_cast<MHCalibrationChargeLoGainPix*>(fAverageLoGainAreas->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th pixel (pixel number)
+//
+const MHCalibrationChargeLoGainPix &MHCalibrationChargeCam::GetAverageLoGainArea(UInt_t i) const
+{
+  return *static_cast<MHCalibrationChargeLoGainPix*>(fAverageLoGainAreas->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th pixel (pixel number)
+//
+MHCalibrationChargeHiGainPix &MHCalibrationChargeCam::GetAverageHiGainSector(UInt_t i)
+{
+  return *static_cast<MHCalibrationChargeHiGainPix*>(fAverageHiGainSectors->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th pixel (pixel number)
+//
+const MHCalibrationChargeHiGainPix &MHCalibrationChargeCam::GetAverageHiGainSector(UInt_t i) const
+{
+  return *static_cast<MHCalibrationChargeHiGainPix*>(fAverageHiGainSectors->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th pixel (pixel number)
+//
+MHCalibrationChargeLoGainPix &MHCalibrationChargeCam::GetAverageLoGainSector(UInt_t i)
+{
+  return *static_cast<MHCalibrationChargeLoGainPix*>(fAverageLoGainSectors->UncheckedAt(i));
+}
+
+// --------------------------------------------------------------------------
+//
+// Get i-th pixel (pixel number)
+//
+const MHCalibrationChargeLoGainPix &MHCalibrationChargeCam::GetAverageLoGainSector(UInt_t i) const
+{
+  return *static_cast<MHCalibrationChargeLoGainPix*>(fAverageLoGainSectors->UncheckedAt(i));
 }
 
@@ -219 +264 @@
   const Int_t nhi   = fHiGainArray->GetEntries();
   const Int_t nlo   = fLoGainArray->GetEntries();
-  const Int_t navhi = fAverageHiGainArray->GetEntries();
-  const Int_t navlo = fAverageLoGainArray->GetEntries();
-  
-  *fLog << err << nhi << "  " << nlo << "  " << navhi << "  " << navlo << endl;
-
+  const Int_t navhi = fAverageHiGainAreas->GetEntries();
+  const Int_t navlo = fAverageLoGainAreas->GetEntries();
+  const Int_t nsehi = fAverageHiGainSectors->GetEntries();
+  const Int_t nselo = fAverageLoGainSectors->GetEntries();
+  
   //
   // FIXME, this might be done faster and more elegant, by direct copy.
@@ -231 +276 @@
   cam->fHiGainArray->Expand(nhi);
   cam->fLoGainArray->Expand(nlo);
-  cam->fAverageHiGainArray->Expand(navhi);
-  cam->fAverageLoGainArray->Expand(navlo);
+  cam->fAverageHiGainAreas->Expand(navhi);
+  cam->fAverageLoGainAreas->Expand(navlo);
+  cam->fAverageHiGainSectors->Expand(nsehi);
+  cam->fAverageLoGainSectors->Expand(nselo);
 
   for (int i=0; i<nhi; i++)
@@ -246 +293 @@
   for (int i=0; i<navhi; i++)
     {
-      delete (*cam->fAverageHiGainArray)[i];
-      (*cam->fAverageHiGainArray)[i] = (MHCalibrationChargeHiGainPix*)(*fAverageHiGainArray)[i]->Clone();
+      delete (*cam->fAverageHiGainAreas)[i];
+      (*cam->fAverageHiGainAreas)[i] = (MHCalibrationChargeHiGainPix*)(*fAverageHiGainAreas)[i]->Clone();
     }
   for (int i=0; i<navlo; i++)
     {
-      delete (*cam->fAverageLoGainArray)[i];
-      (*cam->fAverageLoGainArray)[i] = (MHCalibrationChargeLoGainPix*)(*fAverageLoGainArray)[i]->Clone();
-    }
-
-  cam->fAverageNum            = fAverageNum;           
-  cam->fAverageSat            = fAverageSat;            
-  cam->fAveragePixSigma       = fAveragePixSigma;      
-  cam->fAveragePixSigmaErr    = fAveragePixSigmaErr;   
-  cam->fAveragePixRelSigma    = fAveragePixRelSigma;
-  cam->fAveragePixRelSigmaErr = fAveragePixRelSigmaErr;   
+      delete (*cam->fAverageLoGainAreas)[i];
+      (*cam->fAverageLoGainAreas)[i] = (MHCalibrationChargeLoGainPix*)(*fAverageLoGainAreas)[i]->Clone();
+    }
+  for (int i=0; i<nsehi; i++)
+    {
+      delete (*cam->fAverageHiGainSectors)[i];
+      (*cam->fAverageHiGainSectors)[i] = (MHCalibrationChargeHiGainPix*)(*fAverageHiGainSectors)[i]->Clone();
+    }
+  for (int i=0; i<nselo; i++)
+    {
+      delete (*cam->fAverageLoGainSectors)[i];
+      (*cam->fAverageLoGainSectors)[i] = (MHCalibrationChargeLoGainPix*)(*fAverageLoGainSectors)[i]->Clone();
+    }
+
+  cam->fAverageAreaSat         = fAverageAreaSat;            
+  cam->fAverageAreaSigma       = fAverageAreaSigma;      
+  cam->fAverageAreaSigmaErr    = fAverageAreaSigmaErr;   
+  cam->fAverageAreaRelSigma    = fAverageAreaRelSigma;
+  cam->fAverageAreaRelSigmaErr = fAverageAreaRelSigmaErr;   
 
   return cam;
@@ -290 +346 @@
   fLoGainArray->Delete();
 
-  fAverageHiGainArray->Delete();
-  fAverageLoGainArray->Delete();
+  fAverageHiGainAreas->Delete();
+  fAverageLoGainAreas->Delete();
+
+  fAverageHiGainSectors->Delete();
+  fAverageLoGainSectors->Delete();
 
   return kTRUE;
@@ -364 +423 @@
   const Int_t nareas = fGeom->GetNumAreas();
 
-  if (fAverageHiGainArray->GetEntries()==0)
+  if (fAverageHiGainAreas->GetEntries()==0)
   {
-      fAverageHiGainArray->Expand(nareas);
+      fAverageHiGainAreas->Expand(nareas);
 
       for (Int_t j=0; j<nareas; j++)
@@ -373 +432 @@
           // Oscillating pixels
           //
-          (*fAverageHiGainArray)[j] = 
-            new MHCalibrationChargeHiGainPix("AverageHiGainPix",
+          (*fAverageHiGainAreas)[j] = 
+            new MHCalibrationChargeHiGainPix("AverageHiGainArea",
                                              "Average HiGain FADC sums of pixel area idx ");
-          MHCalibrationChargeHiGainPix &hist = GetAverageHiGainPix(j);
+          MHCalibrationChargeHiGainPix &hist = GetAverageHiGainArea(j);
 
           hist.GetHGausHist()->SetTitle("Summed FADC slices average Hi Gain pixels Area Idx ");
@@ -389 +448 @@
   }
 
-  if (fAverageLoGainArray->GetEntries()==0)
+  if (fAverageLoGainAreas->GetEntries()==0)
   {
-      fAverageLoGainArray->Expand(nareas);
+      fAverageLoGainAreas->Expand(nareas);
   
       for (Int_t j=0; j<nareas; j++)
@@ -398 +457 @@
           // Oscillating pixels
           //
-          (*fAverageLoGainArray)[j] = 
-            new MHCalibrationChargeLoGainPix("AverageLoGainPix",
+          (*fAverageLoGainAreas)[j] = 
+            new MHCalibrationChargeLoGainPix("AverageLoGainArea",
                                              "Average LoGain FADC sums of pixel area idx ");
-          MHCalibrationChargeLoGainPix &hist = GetAverageLoGainPix(j);
+          MHCalibrationChargeLoGainPix &hist = GetAverageLoGainArea(j);
 
           hist.GetHGausHist()->SetTitle("Summed FADC slices average Lo Gain pixels Area Idx ");
@@ -414 +473 @@
   }
 
-  fAverageNum.           Set(nareas);
-  fAverageSat.           Set(nareas);           
-  fAveragePixSigma.      Set(nareas);      
-  fAveragePixSigmaErr.   Set(nareas);   
-  fAveragePixRelSigma.   Set(nareas);   
-  fAveragePixRelSigmaErr.Set(nareas);
+  fAverageAreaNum.        Set(nareas);
+  fAverageAreaSat.        Set(nareas);           
+  fAverageAreaSigma.      Set(nareas);      
+  fAverageAreaSigmaErr.   Set(nareas);   
+  fAverageAreaRelSigma.   Set(nareas);   
+  fAverageAreaRelSigmaErr.Set(nareas);
     
   for (Int_t i=0; i<n; i++)
@@ -427 +486 @@
 
       const Int_t aidx  = (*fGeom)[i].GetAidx();
-      fAverageNum[aidx]++;
-    }
+      fAverageAreaNum[aidx]++;
+    }
+
+
+  const Int_t nsectors = fGeom->GetNumSectors();
+
+  if (fAverageHiGainSectors->GetEntries()==0)
+  {
+      fAverageHiGainSectors->Expand(nsectors);
+
+      for (Int_t j=0; j<nsectors; j++)
+      {
+          //
+          // Oscillating pixels
+          //
+          (*fAverageHiGainSectors)[j] = 
+            new MHCalibrationChargeHiGainPix("AverageHiGainSector",
+                                             "Average HiGain FADC sums of pixel sector ");
+          MHCalibrationChargeHiGainPix &hist = GetAverageHiGainSector(j);
+
+          hist.GetHGausHist()->SetTitle("Summed FADC slices average Hi Gain pixels Sector ");
+          hist.GetHAbsTime()->SetTitle("Absolute Arrival Time average Hi Gain pixels Sector ");
+          hist.SetChargeFirst(-1000.);
+          hist.SetChargeLast(4000.);
+          hist.SetChargeNbins(4000);
+          hist.Init();
+          hist.ChangeHistId(j);
+          hist.SetEventFrequency(fPulserFrequency);
+      }
+  }
+
+  if (fAverageLoGainSectors->GetEntries()==0)
+  {
+      fAverageLoGainSectors->Expand(nsectors);
+  
+      for (Int_t j=0; j<nsectors; j++)
+      {
+          //
+          // Oscillating pixels
+          //
+          (*fAverageLoGainSectors)[j] = 
+            new MHCalibrationChargeLoGainPix("AverageLoGainSector",
+                                             "Average LoGain FADC sums of pixel sector ");
+          MHCalibrationChargeLoGainPix &hist = GetAverageLoGainSector(j);
+
+          hist.GetHGausHist()->SetTitle("Summed FADC slices average Lo Gain pixels Sector ");
+          hist.GetHAbsTime()->SetTitle("Absolute Arrival Time average Lo Gain pixels Sector ");
+          hist.SetChargeFirst(-1000.);
+          hist.SetChargeLast(4000.);
+          hist.SetChargeNbins(4000);
+          hist.Init();
+          hist.ChangeHistId(j);
+          hist.SetEventFrequency(fPulserFrequency);
+      }
+  }
+
+  fAverageSectorNum.        Set(nsectors);
+
+  for (Int_t i=0; i<n; i++)
+    {
+      if ((*this)[i].IsExcluded())
+        continue;
+
+      const Int_t sector  = (*fGeom)[i].GetSector();
+      fAverageSectorNum[sector]++;
+    }
+
   
   return kTRUE;
@@ -445 +569 @@
     }
   
-  const Int_t npixels = signal->GetSize();
-  const Int_t lofirst = signal->GetFirstUsedSliceLoGain();
-  const Int_t nareas  = fGeom->GetNumAreas();
+  const Int_t npixels  = signal->GetSize();
+  const Int_t lofirst  = signal->GetFirstUsedSliceLoGain();
+  const Int_t nareas   = fGeom->GetNumAreas();
+  const Int_t nsectors = fGeom->GetNumSectors();
 
   if (fHiGainArray->GetEntries() != npixels)
@@ -461 +586 @@
     }
 
-  if (fAverageHiGainArray->GetEntries() != nareas)
+  if (fAverageHiGainAreas->GetEntries() != nareas)
     {
       *fLog << err << "ERROR - Size mismatch in number of areas ... abort." << endl;
@@ -467 +592 @@
     }
 
-  if (fAverageLoGainArray->GetEntries() != nareas)
+  if (fAverageLoGainAreas->GetEntries() != nareas)
     {
       *fLog << err << "ERROR - Size mismatch in number of areas ... abort." << endl;
@@ -473 +598 @@
     }
 
-
-  //
-  // First the extracted signal
-  // 
-  Float_t sumhitot [nareas];
-  Float_t sumlotot [nareas];
-  Int_t   sumhisat [nareas];
-  Int_t   sumlosat [nareas];
-  Float_t timehitot[nareas];
-  Float_t timelotot[nareas];
+  if (fAverageHiGainSectors->GetEntries() != nsectors)
+    {
+      *fLog << err << "ERROR - Size mismatch in number of sectors ... abort." << endl;
+      return kFALSE;
+    }
+
+  if (fAverageLoGainSectors->GetEntries() != nsectors)
+    {
+      *fLog << err << "ERROR - Size mismatch in number of sectors ... abort." << endl;
+      return kFALSE;
+    }
+
+  Float_t sumhiarea  [nareas],   sumloarea  [nareas],   timehiarea  [nareas],   timeloarea  [nareas];
+  Float_t sumhisector[nsectors], sumlosector[nsectors], timehisector[nsectors], timelosector[nsectors];
+  Int_t   sathiarea  [nareas],   satloarea  [nareas];
+  Int_t   sathisector[nsectors], satlosector[nsectors];
 
   for (UInt_t j=0; j<nareas; j++)
     {
-
-      sumhitot[j]  =  sumlotot[j]  = 0.;
-      sumhisat[j]  =  sumlosat[j]  = 0;
-      timehitot[j] =  timelotot[j] = 0.;      
+      sumhiarea  [j] = sumloarea  [j] = timehiarea  [j] =  timeloarea  [j] = 0.;
+      sumhisector[j] = sumlosector[j] = timehisector[j] =  timelosector[j] = 0.;
+      sathiarea  [j] = satloarea  [j] = 0;
+      sathisector[j] = satlosector[j] = 0;
     }
   
@@ -512 +643 @@
       (*this)(i).SetSaturated(satlo); 
 
-      const Int_t aidx  = (*fGeom)[i].GetAidx();
-
-      sumhitot[aidx]  += sumhi;
-      sumlotot[aidx]  += sumlo;
-      sumhisat[aidx]  += sathi;
-      sumlosat[aidx]  += satlo;
+      const Int_t aidx   = (*fGeom)[i].GetAidx();
+      const Int_t sector = (*fGeom)[i].GetSector();
+
+      sumhiarea[aidx]  += sumhi;
+      sumloarea[aidx]  += sumlo;
+      sathiarea[aidx]  += sathi;
+      satloarea[aidx]  += satlo;
+
+      sumhisector[sector]  += sumhi;
+      sumlosector[sector]  += sumlo;
+      sathisector[sector]  += sathi;
+      satlosector[sector]  += satlo;
     }
 
@@ -534 +671 @@
       (*this)(pixid).FillAbsTime(timelo);
 
-      const Int_t aidx  = (*fGeom)[pixid].GetAidx();
-
-      timehitot[aidx] += timehi;
-      timelotot[aidx] += timelo;
+      const Int_t aidx   = (*fGeom)[pixid].GetAidx();
+      const Int_t sector = (*fGeom)[pixid].GetSector();
+
+      timehiarea[aidx] += timehi;
+      timeloarea[aidx] += timelo;
+
+      timehisector[sector] += timehi;
+      timelosector[sector] += timelo;
     }
   
@@ -544 +685 @@
     {
 
-      const Int_t npix = fAverageNum[j];
-
-      MHCalibrationChargeHiGainPix &hipix = GetAverageHiGainPix(j);
-      MHCalibrationChargeLoGainPix &lopix = GetAverageLoGainPix(j);
-
-      hipix.FillHistAndArray(sumhitot[j]/npix);
-      lopix.FillHistAndArray(sumlotot[j]/npix);
-
-      hipix.SetSaturated((Float_t)sumhisat[j]/npix); 
-      lopix.SetSaturated((Float_t)sumlosat[j]/npix); 
-
-      hipix.FillAbsTime(timehitot[j]/npix);
-      lopix.FillAbsTime(timelotot[j]/npix);
+      const Int_t npix = fAverageAreaNum[j];
+
+      MHCalibrationChargeHiGainPix &hipix = GetAverageHiGainArea(j);
+      MHCalibrationChargeLoGainPix &lopix = GetAverageLoGainArea(j);
+
+      hipix.FillHistAndArray(sumhiarea[j]/npix);
+      lopix.FillHistAndArray(sumloarea[j]/npix);
+
+      hipix.SetSaturated((Float_t)sathiarea[j]/npix); 
+      lopix.SetSaturated((Float_t)satloarea[j]/npix); 
+
+      hipix.FillAbsTime(timehiarea[j]/npix);
+      lopix.FillAbsTime(timeloarea[j]/npix);
+
+    }
+
+  for (UInt_t j=0; j<nsectors; j++)
+    {
+
+      const Int_t npix = fAverageSectorNum[j];
+
+      MHCalibrationChargeHiGainPix &hipix = GetAverageHiGainSector(j);
+      MHCalibrationChargeLoGainPix &lopix = GetAverageLoGainSector(j);
+
+      hipix.FillHistAndArray(sumhisector[j]/npix);
+      lopix.FillHistAndArray(sumlosector[j]/npix);
+
+      hipix.SetSaturated((Float_t)sathisector[j]/npix); 
+      lopix.SetSaturated((Float_t)satlosector[j]/npix); 
+
+      hipix.FillAbsTime(timehisector[j]/npix);
+      lopix.FillAbsTime(timelosector[j]/npix);
 
     }
@@ -604 +764 @@
     }
   
-  for (Int_t j=0; j<fAverageHiGainArray->GetSize(); j++)
-    {
-      
-      MHCalibrationChargeHiGainPix &histhi = GetAverageHiGainPix(j);      
-      MCalibrationChargePix        &pix    = fCam->GetAveragePix(j);
-      MBadPixelsPix                &bad    = fCam->GetAverageBadPix(j);        
+  for (Int_t j=0; j<fAverageHiGainAreas->GetSize(); j++)
+    {
+      
+      MHCalibrationChargeHiGainPix &histhi = GetAverageHiGainArea(j);      
+      MCalibrationChargePix        &pix    = fCam->GetAverageArea(j);
+      MBadPixelsPix                &bad    = fCam->GetAverageBadArea(j);        
       
       FinalizeHiGainHists(histhi,pix,bad);
     }
   
-  for (Int_t j=0; j<fAverageLoGainArray->GetSize(); j++)
-    {
-      
-      MHCalibrationChargeLoGainPix &histlo = GetAverageLoGainPix(j);      
-      MCalibrationChargePix        &pix    = fCam->GetAveragePix(j);
-      MBadPixelsPix                &bad    = fCam->GetAverageBadPix(j);        
+  for (Int_t j=0; j<fAverageLoGainAreas->GetSize(); j++)
+    {
+      
+      MHCalibrationChargeLoGainPix &histlo = GetAverageLoGainArea(j);      
+      MCalibrationChargePix        &pix    = fCam->GetAverageArea(j);
+      MBadPixelsPix                &bad    = fCam->GetAverageBadArea(j);        
       
       FinalizeLoGainHists(histlo,pix,bad);
     }
+
+  for (Int_t j=0; j<fAverageHiGainSectors->GetSize(); j++)
+    {
+      
+      MHCalibrationChargeHiGainPix &histhi = GetAverageHiGainSector(j);      
+      MCalibrationChargePix        &pix    = fCam->GetAverageSector(j);
+      MBadPixelsPix                &bad    = fCam->GetAverageBadSector(j);        
+      
+      FinalizeHiGainHists(histhi,pix,bad);
+    }
+  
+  for (Int_t j=0; j<fAverageLoGainSectors->GetSize(); j++)
+    {
+      
+      MHCalibrationChargeLoGainPix &histlo = GetAverageLoGainSector(j);      
+      MCalibrationChargePix        &pix    = fCam->GetAverageSector(j);
+      MBadPixelsPix                &bad    = fCam->GetAverageBadSector(j);        
+      
+      FinalizeLoGainHists(histlo,pix,bad);
+    }
   
   for (Int_t j=0; j<fGeom->GetNumAreas();j++)
     {
       
-      MCalibrationChargePix &pix = fCam->GetAveragePix(j);
+      MCalibrationChargePix &pix = fCam->GetAverageArea(j);
 
       if (pix.IsHiGainSaturation())
-        fAverageSat[j]++;
-
-      fAveragePixSigma[j]    = pix.GetSigmaCharge    () * TMath::Sqrt((Float_t)fAverageNum[j]);
-      fAveragePixSigmaErr[j] = pix.GetSigmaChargeErr () * TMath::Sqrt((Float_t)fAverageNum[j]);
-
-      pix.SetSigmaCharge   (fAveragePixSigma[j]);
-      pix.SetSigmaChargeErr(fAveragePixSigmaErr[j]);
-
-      fAveragePixRelSigma[j]   = fAveragePixSigma[j] / pix.GetMeanCharge();
-      
-      Float_t relsigmaerr      =  fAveragePixSigmaErr[j]*fAveragePixSigmaErr[j] 
-                               / (fAveragePixSigma[j]   *fAveragePixSigma[j]   );
-      relsigmaerr              += pix.GetMeanChargeErr()*pix.GetMeanChargeErr() 
-                               / (pix.GetMeanCharge()   *pix.GetMeanCharge()   );
-      relsigmaerr              *= fAveragePixRelSigma[j];
-      fAveragePixRelSigmaErr[j] = TMath::Sqrt(relsigmaerr);
+        fAverageAreaSat[j]++;
+
+      fAverageAreaSigma[j]    = pix.GetSigmaCharge    () * TMath::Sqrt((Float_t)fAverageAreaNum[j]);
+      fAverageAreaSigmaErr[j] = pix.GetSigmaChargeErr () * TMath::Sqrt((Float_t)fAverageAreaNum[j]);
+
+      pix.SetSigmaCharge   (fAverageAreaSigma[j]);
+      pix.SetSigmaChargeErr(fAverageAreaSigmaErr[j]);
+
+      fAverageAreaRelSigma[j]   = fAverageAreaSigma[j] / pix.GetMeanCharge();
+      
+      Float_t relsigmaerr       =  fAverageAreaSigmaErr[j]*fAverageAreaSigmaErr[j] 
+                                / (fAverageAreaSigma[j]   *fAverageAreaSigma[j]   );
+      relsigmaerr               += pix.GetMeanChargeErr()*pix.GetMeanChargeErr() 
+                                / (pix.GetMeanCharge()   *pix.GetMeanCharge()   );
+      relsigmaerr               *= fAverageAreaRelSigma[j];
+      fAverageAreaRelSigmaErr[j] = TMath::Sqrt(relsigmaerr);
 
     }
@@ -668 +848 @@
       *fLog << warn << "Saturated Hi Gain histogram in pixel: " << pix.GetPixId() << endl;
       pix.SetHiGainSaturation();
-      return;
+      //      return;
     }
     
@@ -737 +917 @@
       bad.SetUncalibrated( MBadPixelsPix::kLoGainSaturation ); 
       bad.SetUnsuitable(   MBadPixelsPix::kUnsuitableRun    );
-      return;
+      //      return;
     }
 
@@ -810 +990 @@
 {
 
-  const Int_t nareas = fAverageHiGainArray->GetEntries();
+  const Int_t nareas = fAverageHiGainAreas->GetEntries();
   if (nareas == 0)
     return;
@@ -822 +1002 @@
     {
       pad->cd(2*(i+1)-1);
-      GetAverageHiGainPix(i).Draw(opt);
-
-      if (!fAverageSat[i])
-        DrawAverageSigma(fAverageSat[i], i,
-                         fAveragePixSigma[i],    fAveragePixSigmaErr[i],
-                         fAveragePixRelSigma[i], fAveragePixRelSigmaErr[i]);
+      GetAverageHiGainArea(i).Draw(opt);
+
+      if (!fAverageAreaSat[i])
+        DrawAverageSigma(fAverageAreaSat[i], i,
+                         fAverageAreaSigma[i],    fAverageAreaSigmaErr[i],
+                         fAverageAreaRelSigma[i], fAverageAreaRelSigmaErr[i]);
 
       pad->cd(2*(i+1));
-      GetAverageLoGainPix(i).Draw(opt);
-      
-      if (fAverageSat[i])
-        DrawAverageSigma(fAverageSat[i], i,
-                         fAveragePixSigma[i], fAveragePixSigmaErr[i],
-                         fAveragePixRelSigma[i], fAveragePixRelSigmaErr[i]);
+      GetAverageLoGainArea(i).Draw(opt);
+      
+      if (fAverageAreaSat[i])
+        DrawAverageSigma(fAverageAreaSat[i], i,
+                         fAverageAreaSigma[i], fAverageAreaSigmaErr[i],
+                         fAverageAreaRelSigma[i], fAverageAreaRelSigmaErr[i]);
     }
 }

trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeCam.h

@@ -47 +47 @@
   TObjArray *fHiGainArray;            //-> Array of MHCalibrationChargeHiGainPix, one per pixel
   TObjArray *fLoGainArray;            //-> Array of MHCalibrationChargeLoGainPix, one per pixel
-  TObjArray *fAverageHiGainArray;     //-> Array of MHCalibrationChargeHiGainPix, one per pixel area
-  TObjArray *fAverageLoGainArray;     //-> Array of MHCalibrationChargeLoGainPix, one per pixel area
-  
+  TObjArray *fAverageHiGainAreas;     //-> Array of MHCalibrationChargeHiGainPix, one per pixel area
+  TObjArray *fAverageLoGainAreas;     //-> Array of MHCalibrationChargeLoGainPix, one per pixel area
+  TObjArray *fAverageHiGainSectors;   //-> Array of MHCalibrationChargeHiGainPix, one per camera sector
+  TObjArray *fAverageLoGainSectors;   //-> Array of MHCalibrationChargeLoGainPix, one per camera sector
+
   MCalibrationChargeCam  *fCam;       //!  Calibration Cam with the results
   MRawEvtData            *fRawEvt;    //!  Raw event data 
@@ -55 +57 @@
   MBadPixelsCam          *fBadPixels; //!  Bad Pixels storage container
 
-  TArrayI fAverageNum;                // Number of pixels in average pixels
-  TArrayI fAverageSat;                // Number of saturated slices in average pixels
-  TArrayF fAveragePixSigma;           // Re-normalized sigmas in average pixels
-  TArrayF fAveragePixSigmaErr;        // Errors of Re-normalized sigmas in average pixels
-  TArrayF fAveragePixRelSigma;        // Re-normalized relative sigmas in average pixels
-  TArrayF fAveragePixRelSigmaErr;     // Errors of Re-normalized relative sigmas in average pixels
+  TArrayI fAverageAreaNum;            // Number of pixels in average pixels per area
+  TArrayI fAverageAreaSat;            // Number of saturated slices in average pixels per area
+  TArrayF fAverageAreaSigma;          // Re-normalized sigmas in average pixels per area
+  TArrayF fAverageAreaSigmaErr;       // Errors of Re-normalized sigmas in average pixels per area
+  TArrayF fAverageAreaRelSigma;       // Re-normalized relative sigmas in average pixels per area
+  TArrayF fAverageAreaRelSigmaErr;    // Errors of Re-normalized relative sigmas in average pixels per area
+
+  TArrayI fAverageSectorNum;          // Number of pixels in average pixels per sector 
 
   void FinalizeHiGainHists(MHCalibrationChargeHiGainPix &hist, MCalibrationChargePix &pix, MBadPixelsPix &bad);
@@ -86 +90 @@
   const MHCalibrationChargeLoGainPix &operator()(UInt_t i)    const;
 
-        MHCalibrationChargeHiGainPix  &GetAverageHiGainPix(UInt_t i);
-  const MHCalibrationChargeHiGainPix  &GetAverageHiGainPix(UInt_t i)  const;
+        MHCalibrationChargeHiGainPix  &GetAverageHiGainArea(UInt_t i);
+  const MHCalibrationChargeHiGainPix  &GetAverageHiGainArea(UInt_t i)  const;
 
-        MHCalibrationChargeLoGainPix  &GetAverageLoGainPix(UInt_t i);
-  const MHCalibrationChargeLoGainPix  &GetAverageLoGainPix(UInt_t i)  const;
+        MHCalibrationChargeLoGainPix  &GetAverageLoGainArea(UInt_t i);
+  const MHCalibrationChargeLoGainPix  &GetAverageLoGainArea(UInt_t i)  const;
+
+        MHCalibrationChargeHiGainPix  &GetAverageHiGainSector(UInt_t i);
+  const MHCalibrationChargeHiGainPix  &GetAverageHiGainSector(UInt_t i)  const;
+
+        MHCalibrationChargeLoGainPix  &GetAverageLoGainSector(UInt_t i);
+  const MHCalibrationChargeLoGainPix  &GetAverageLoGainSector(UInt_t i)  const;
 
   Bool_t SetupFill(const MParList *pList);
@@ -106 +116 @@
   void   DrawPixelContent( Int_t num )  const;    
 
-  ClassDef(MHCalibrationChargeCam, 1)   // Container for calibration information of the camera
+  ClassDef(MHCalibrationChargeCam, 1)   // Histogram class for camera calibration 
 };