Index: /trunk/MagicSoft/Mars/Changelog
===================================================================
--- /trunk/MagicSoft/Mars/Changelog	(revision 5031)
+++ /trunk/MagicSoft/Mars/Changelog	(revision 5032)
@@ -67,4 +67,5 @@
 
    * mhcalib/MHCalibrationChargeCam.cc
+   * mcalib/MCalibrationChargeCalc.cc
      - simply calls to IntensityCam somewhat
 
Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc	(revision 5031)
+++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc	(revision 5032)
@@ -48,5 +48,4 @@
 //                  - FinalizeFFactorMethod()
 //                  - FinalizeBadPixels()
-//                  - FinalizeBlindPixel()
 //                  - FinalizeBlindCam()
 //                  - FinalizePINDiode()
@@ -466,5 +465,6 @@
         {
           *fLog << endl;
-          *fLog << warn << "No MCalibrationBlindCam found... no Blind Pixel method! " << endl;
+          *fLog << warn << GetDescriptor() 
+                << ": No MCalibrationBlindCam found... no Blind Pixel method! " << endl;
           return kFALSE;
         }
@@ -491,5 +491,6 @@
     {
       *fLog << endl;
-      *fLog << "MCalibrationChargePINDiode not found... no PIN Diode method! " << endl;
+      *fLog << warn << GetDescriptor() 
+            << ": MCalibrationChargePINDiode not found... no PIN Diode method! " << endl;
     }
   
@@ -649,5 +650,4 @@
 // Call FinalizeFFactorMethod() (second and third loop over pixels and areas)
 //
-// Call FinalizeBlindPixel() 
 // Call FinalizeBlindCam() 
 // Call FinalizePINDiode()
@@ -681,4 +681,14 @@
 
   *fLog << endl;
+
+  MCalibrationBlindCam  *blindcam  = fIntensBlind   
+    ? (MCalibrationBlindCam*)fIntensBlind->GetCam() : fBlindCam;
+  MCalibrationQECam     *qecam     = fIntensQE      
+    ? (MCalibrationQECam*)    fIntensQE->GetCam()   : fQECam;
+  MCalibrationChargeCam *chargecam = fIntensCam 
+    ? (MCalibrationChargeCam*)fIntensCam->GetCam()  : fCam;
+  MBadPixelsCam         *badcam    = fIntensBad 
+    ? (MBadPixelsCam*)        fIntensBad->GetCam()  : fBadPixels;
+
   //
   // First loop over pixels, call FinalizePedestals and FinalizeCharges
@@ -689,7 +699,5 @@
     {
 
-      MCalibrationChargePix &pix = fIntensCam 
-        ? (MCalibrationChargePix&)(*fIntensCam)[pixid]
-        : (MCalibrationChargePix&)(*fCam)[pixid];
+      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*chargecam)[pixid];
       //
       // Check if the pixel has been excluded from the fits
@@ -699,7 +707,6 @@
 
       MPedestalPix  &ped = (*fPedestals)[pixid];
-      MBadPixelsPix &bad = fIntensBad 
-        ? (*fIntensBad)[pixid]
-        : (*fBadPixels)[pixid];
+      MBadPixelsPix &bad = (*badcam)    [pixid];
+
       const Int_t aidx    = (*fGeom)[pixid].GetAidx();
 
@@ -728,7 +735,5 @@
 
       const MPedestalPix     &ped = fPedestals->GetAverageArea(aidx);
-      MCalibrationChargePix &pix = fIntensCam
-        ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
-        : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
+      MCalibrationChargePix &pix = (MCalibrationChargePix&)chargecam->GetAverageArea(aidx);
 
       FinalizePedestals(ped,pix,aidx);
@@ -745,7 +750,5 @@
       const MPedestalPix     &ped = fPedestals->GetAverageSector(sector);
 
-      MCalibrationChargePix &pix = fIntensCam 
-        ? (MCalibrationChargePix&)fIntensCam->GetAverageSector(sector)
-        : (MCalibrationChargePix&)fCam->GetAverageSector(sector);
+      MCalibrationChargePix &pix = (MCalibrationChargePix&)chargecam->GetAverageSector(sector);
       FinalizePedestals(ped,pix, 0);
     }
@@ -761,35 +764,23 @@
   // Finalize F-Factor method
   //
-  if (!FinalizeFFactorMethod())
+  if (FinalizeFFactorMethod())
+    chargecam->SetFFactorMethodValid(kTRUE);
+  else
     {
       *fLog << warn << "Could not calculate the photons flux from the F-Factor method " << endl;
-      if (fIntensCam)
-        fIntensCam->SetFFactorMethodValid(kFALSE); 
-      else
-        fCam->SetFFactorMethodValid(kFALSE); 
+      chargecam->SetFFactorMethodValid(kFALSE); 
       return kFALSE;
     }
-  else
-    if (fIntensCam)
-      fIntensCam->SetFFactorMethodValid(kTRUE);
-    else
-      fCam->SetFFactorMethodValid(kTRUE);
-  
+
   *fLog << endl;
   // 
   // Finalize Blind Pixel
   //
-  if (fIntensQE)
-    fIntensQE->SetBlindPixelMethodValid(FinalizeBlindCam());
-  else
-    fQECam->SetBlindPixelMethodValid(FinalizeBlindCam()); 
+  qecam->SetBlindPixelMethodValid(FinalizeBlindCam());
 
   // 
   // Finalize PIN Diode
   //
-  if (fIntensQE)
-    fIntensQE->SetBlindPixelMethodValid(FinalizePINDiode());
-  else
-    fQECam->SetBlindPixelMethodValid(FinalizePINDiode()); 
+  qecam->SetBlindPixelMethodValid(FinalizePINDiode());
 
   //
@@ -812,23 +803,10 @@
   FinalizeUnsuitablePixels();
 
-  if (fIntensCam)
-    fIntensCam->SetReadyToSave();
-  else
-    fCam      ->SetReadyToSave();
-
-  if (fIntensQE)
-    fIntensQE ->SetReadyToSave();
-  else
-    fQECam    ->SetReadyToSave();
-
-  if (fIntensBad)
-    fIntensBad->SetReadyToSave();
-  else
-    fBadPixels->SetReadyToSave();
-
-  if (fIntensBlind)
-    fIntensBlind->SetReadyToSave();
-  if (fBlindCam)
-    fBlindCam->SetReadyToSave();
+  chargecam->SetReadyToSave();
+  qecam    ->SetReadyToSave();
+  badcam   ->SetReadyToSave();
+  
+  if (blindcam)
+    blindcam->SetReadyToSave();
   if (fPINDiode)
     fPINDiode->SetReadyToSave();
@@ -1021,9 +999,14 @@
 {
   
-  for (Int_t i=0; i<fBadPixels->GetSize(); i++)
-    {
-      
-      MBadPixelsPix    &bad    = fIntensBad ? (*fIntensBad)[i] : (*fBadPixels)[i];
-      MCalibrationPix  &pix    = fIntensCam ? (*fIntensCam)[i] : (*fCam)[i];
+  MBadPixelsCam         *badcam    = fIntensBad 
+    ? (MBadPixelsCam*)        fIntensBad->GetCam()  : fBadPixels;
+  MCalibrationChargeCam *chargecam = fIntensCam 
+    ? (MCalibrationChargeCam*)fIntensCam->GetCam()  : fCam;
+
+  for (Int_t i=0; i<badcam->GetSize(); i++)
+    {
+      
+      MBadPixelsPix    &bad    = (*badcam)   [i];
+      MCalibrationPix  &pix    = (*chargecam)[i];
 
       if (IsCheckDeadPixels())
@@ -1104,4 +1087,9 @@
 {
 
+  MBadPixelsCam         *badcam    = fIntensBad 
+    ? (MBadPixelsCam*)        fIntensBad->GetCam()  : fBadPixels;
+  MCalibrationChargeCam *chargecam = fIntensCam 
+    ? (MCalibrationChargeCam*)fIntensCam->GetCam()  : fCam;
+
   const Int_t npixels  = fGeom->GetNumPixels();
   const Int_t nareas   = fGeom->GetNumAreas();
@@ -1127,10 +1115,6 @@
     {
       
-      MCalibrationChargePix &pix = fIntensCam 
-        ? (MCalibrationChargePix&)(*fIntensCam)[i]
-        : (MCalibrationChargePix&)(*fCam)  [i];
-      MBadPixelsPix         &bad = fIntensBad 
-        ? (*fIntensBad)[i]
-        : (*fBadPixels)[i];
+      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*chargecam)[i];
+      MBadPixelsPix         &bad =                         (*badcam)[i];
       
       if (!pix.IsFFactorMethodValid())
@@ -1244,14 +1228,10 @@
     {
       
-      MCalibrationChargePix &pix = fIntensCam 
-        ? (MCalibrationChargePix&)(*fIntensCam)[i]
-        : (MCalibrationChargePix&)(*fCam)[i];
+      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*chargecam)[i];
 
       if (!pix.IsFFactorMethodValid())
         continue;
 
-      MBadPixelsPix         &bad = fIntensBad 
-        ? (*fIntensBad)[i]
-        : (*fBadPixels)[i];
+      MBadPixelsPix         &bad =           (*badcam)[i];
 
       if (bad.IsUncalibrated(MBadPixelsPix::kChargeSigmaNotValid))
@@ -1302,7 +1282,5 @@
     {
 
-      MCalibrationChargePix &apix = fIntensCam 
-        ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
-        : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
+      MCalibrationChargePix &apix = (MCalibrationChargePix&)chargecam->GetAverageArea(aidx);
 
       if (numareavalid[aidx] == 1)
@@ -1361,7 +1339,5 @@
         }
       
-      MCalibrationChargePix &spix = fIntensCam 
-        ? (MCalibrationChargePix&)fIntensCam->GetAverageSector(sector)
-        : (MCalibrationChargePix&)fCam->GetAverageSector(sector);
+      MCalibrationChargePix &spix = (MCalibrationChargePix&)chargecam->GetAverageSector(sector);
 
       if (sectorweights[sector] < 0. || sectorphes[sector] <= 0.)
@@ -1393,10 +1369,6 @@
     {
       
-      MCalibrationChargePix &pix = fIntensCam
-        ? (MCalibrationChargePix&)(*fIntensCam)[i]
-        : (MCalibrationChargePix&)(*fCam)[i];
-      MBadPixelsPix         &bad = fIntensBad 
-        ? (*fIntensBad)[i]
-        : (*fBadPixels)[i];
+      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*chargecam)[i];
+      MBadPixelsPix         &bad =                         (*badcam)[i];
 
       if (bad.IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
@@ -1406,7 +1378,6 @@
         {
           const Int_t            aidx = (*fGeom)[i].GetAidx();
-          MCalibrationChargePix &apix = fIntensCam
-            ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
-            : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
+          MCalibrationChargePix &apix = (MCalibrationChargePix&)chargecam->GetAverageArea(aidx);
+
           pix.SetPheFFactorMethod   ( apix.GetPheFFactorMethod()    );
           pix.SetPheFFactorMethodVar( apix.GetPheFFactorMethodVar() );
@@ -1444,17 +1415,11 @@
 {
 
-  if (!fBlindCam && !fIntensBlind)
-    return kFALSE;  
-
-  Float_t flux    = 0.;
-  Float_t fluxvar = 0.;  
-  Int_t   nvalid  = 0;
-
   MCalibrationBlindCam  *blindcam = fIntensBlind   
     ? (MCalibrationBlindCam*)fIntensBlind->GetCam() : fBlindCam;
-  MCalibrationQECam     *qecam    = fIntensQE      
-    ? (MCalibrationQECam*)fIntensQE->GetCam()    : fQECam;
-  MCalibrationChargeCam *chargecam = fIntensCam 
-    ? (MCalibrationChargeCam*)fIntensCam->GetCam()  : fCam;
+
+  if (!blindcam)
+    return kFALSE;  
+
+  Int_t   nvalid  = 0;
 
   for (Int_t i=0; i<blindcam->GetSize(); i++)
@@ -1497,7 +1462,4 @@
       
       nvalid++;
-      const Float_t weight = 1./ blindpix.GetFluxInsidePlexiglassErr() / blindpix.GetFluxInsidePlexiglassErr();
-      flux    += weight * blindpix.GetFluxInsidePlexiglass();
-      fluxvar += weight;
     }
 
@@ -1505,14 +1467,4 @@
     return kFALSE;
   
-  flux    /= fluxvar;
-  fluxvar /= 1./fluxvar;
-
-  const Float_t photons = flux * (*fGeom)[0].GetA() / qecam->GetPlexiglassQE();
-  chargecam->SetNumPhotonsBlindPixelMethod(photons);
-  
-  const Float_t photrelvar = fluxvar / flux / flux + qecam->GetPlexiglassQERelVar();
-  if (photrelvar > 0.)
-    chargecam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
-
   return kTRUE;
 }
@@ -1648,8 +1600,8 @@
   // Set the results in the MCalibrationChargeCam
   //
-  charge->SetNumPhotonsFFactorMethod   (avphotons);
+  chargecam->SetNumPhotonsFFactorMethod (avphotons);
 
   if (avphotrelvar > 0.)
-    charge->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons));  
+    chargecam->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons));  
 
   TArrayF lowlim           (nareas);
@@ -1666,7 +1618,7 @@
     {
       
-      MCalibrationChargePix &avpix = (MCalibrationChargePix&)(*chargecam)[i];
+      MCalibrationChargePix &pix   = (MCalibrationChargePix&)(*chargecam)[i];
       MCalibrationQEPix     &qepix = (MCalibrationQEPix&)    (*qecam)    [i];
-      MBadPixelsPix         &bad =                           (*badcam)   [i];
+      MBadPixelsPix         &bad   =                         (*badcam)   [i];
 
       if (bad.IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
@@ -1843,45 +1795,36 @@
 {
 
-  const UInt_t npixels  = fGeom->GetNumPixels();
-
+
+  MCalibrationBlindCam  *blindcam  = fIntensBlind
+    ? (MCalibrationBlindCam*) fIntensBlind->GetCam(): fBlindCam;
+  MBadPixelsCam         *badcam    = fIntensBad 
+    ? (MBadPixelsCam*)        fIntensBad->GetCam()  : fBadPixels;
   MCalibrationQECam     *qecam     = fIntensQE      
     ? (MCalibrationQECam*)    fIntensQE->GetCam()   : fQECam;
   MCalibrationChargeCam *chargecam = fIntensCam 
     ? (MCalibrationChargeCam*)fIntensCam->GetCam()  : fCam;
-  MCalibrationBlindCam  *blindcam  = fIntensBlind
-    ? (MCalibrationBlindCam*) fIntensBlind->GetCam(): fBlindCam;
-  MBadPixelsCam         *badcam    = fIntensBad 
-    ? (MBadPixelsCam*)        fIntensBad->GetCam()  : fBadPixels;
 
   //
   // Set the results in the MCalibrationChargeCam
   //
-  /*
-  if (blindcam)
-    {
-      if (fBlindPixel->IsFluxInsidePlexiglassAvailable())
-        {
-
-          const Float_t photons = fBlindPixel->GetFluxInsidePlexiglass() * (*fGeom)[0].GetA()
-                               / fQECam->GetPlexiglassQE();
-          if (fIntensCam)
-            fCam->SetNumPhotonsBlindPixelMethod(photons);
-          else
-            fCam->SetNumPhotonsBlindPixelMethod(photons);
-
-          const Float_t photrelvar = fBlindPixel->GetFluxInsidePlexiglassRelVar() 
-                                   + fQECam->GetPlexiglassQERelVar();
-          if (photrelvar > 0.)
-            if (fIntensCam)
-              fIntensCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
-            else
-              fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
-        }
-    }
-  */
+  if (!blindcam || !(blindcam->IsFluxInsidePlexiglassAvailable()))
+    {
+  
+      const Float_t photons = blindcam->GetFluxInsidePlexiglass() * (*fGeom)[0].GetA()
+                           / qecam->GetPlexiglassQE();
+      chargecam->SetNumPhotonsBlindPixelMethod(photons);
+          
+      const Float_t photrelvar = blindcam->GetFluxInsidePlexiglassRelVar() 
+                              + qecam->GetPlexiglassQERelVar();
+ 
+      if (photrelvar > 0.)
+        chargecam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
+    }
+  
   //
   //  With the knowledge of the overall photon flux, calculate the 
   //  quantum efficiencies after the Blind Pixel and PIN Diode method
   //
+  const UInt_t npixels  = fGeom->GetNumPixels();
   for (UInt_t i=0; i<npixels; i++)
     {
@@ -1889,5 +1832,5 @@
       MCalibrationQEPix     &qepix = (MCalibrationQEPix&)    (*qecam)    [i];
       
-      if (!blindcam)
+      if (!blindcam || !(blindcam->IsFluxInsidePlexiglassAvailable()))
         {
           qepix.SetBlindPixelMethodValid(kFALSE, fPulserColor);
@@ -1951,6 +1894,4 @@
   MCalibrationChargeCam *chargecam = fIntensCam 
     ? (MCalibrationChargeCam*)fIntensCam->GetCam()  : fCam;
-  MCalibrationBlindCam  *blindcam  = fIntensBlind
-    ? (MCalibrationBlindCam*) fIntensBlind->GetCam(): fBlindCam;
   MBadPixelsCam         *badcam    = fIntensBad 
     ? (MBadPixelsCam*)        fIntensBad->GetCam()  : fBadPixels;
