Index: trunk/MagicSoft/Mars/Changelog
===================================================================
--- trunk/MagicSoft/Mars/Changelog	(revision 4638)
+++ trunk/MagicSoft/Mars/Changelog	(revision 4639)
@@ -21,4 +21,14 @@
 
 
+ 2004/08/17: Thomas Bretz
+
+   * mcalib/MCalibrateData.[h,cc]:
+     - unrolled some if-else statements to accelerate the algorithm a
+       bit (it is just the bottelneck of calibrating the signal)
+     - made sure that code which in not needed is not executed in
+       this case
+
+
+
  2004/08/16: Thomas Bretz
 
@@ -26,4 +36,6 @@
      - change to support also 'No calibration of data'
      - removed obsolete dependancie on *'FromData' containers
+
+   * mcalib/MCalibrateData.[h,cc], mbadpixels/MBadPixelsCalc.[h,cc]:
      - added member function ReadEnv
 
Index: trunk/MagicSoft/Mars/mcalib/MCalibrateData.cc
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrateData.cc	(revision 4638)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrateData.cc	(revision 4639)
@@ -331,5 +331,6 @@
     // MPedestalCam, MExtractedSignalCam and MCalibrationCam
     //
-    const Float_t slices = fSignals->GetNumUsedHiGainFADCSlices();
+    const Float_t slices     = fSignals->GetNumUsedHiGainFADCSlices();
+    const Float_t sqrtslices = TMath::Sqrt(slices);
 
     // is pixid equal to pixidx ?
@@ -347,5 +348,5 @@
         // pedestals/(used FADC slices)   in [ADC] counts
         const Float_t pedes  = ped.GetPedestal()    * slices;
-        const Float_t pedrms = ped.GetPedestalRms() * TMath::Sqrt(slices);
+        const Float_t pedrms = ped.GetPedestalRms() * sqrtslices;
 
         //
@@ -382,124 +383,110 @@
                                            Float_t &calibConv, Float_t &calibConvVar, Float_t &calibFFactor)
 {
-  //
-  // For the moment, we use only a dummy zenith for the calibration:
-  //
-  const Float_t zenith = -1.;
-
-  hiloconv     = 1.;
-  hiloconverr  = 0.;
-  calibConv    = 1.;
-  calibConvVar = 0.;
-  calibFFactor = 0.;
-  Float_t calibQE       = 1.;
-  Float_t calibQEVar    = 0.;
-  Float_t avMean        = 1.;
-  Float_t avMeanRelVar  = 0.;
-
-  if (fCalibrationMode == kFlatCharge)
-  {
-    MCalibrationChargePix &avpix = (MCalibrationChargePix&)fCalibrations->GetAverageArea(0);
-    avMean       =  avpix.GetMean();
-    avMeanRelVar =  avpix.GetMeanRelVar();
-  }
-
-
-  if(fCalibrationMode!=kNone)
-    {
-      
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCalibrations)[pixidx];
-      
-      hiloconv   = pix.GetConversionHiLo   ();
-      hiloconverr= pix.GetConversionHiLoErr();
-      
-      if (fBadPixels)
-        {
-          MBadPixelsPix &bad = (*fBadPixels)[pixidx];
-          if (bad.IsUnsuitable())
-            return kFALSE;
-        }
-      
-      calibConv      = pix.GetMeanConvFADC2Phe();
-      calibConvVar   = pix.GetMeanConvFADC2PheVar();
-      calibFFactor   = pix.GetMeanFFactorFADC2Phot();
-      
-      MCalibrationQEPix &qe  = (MCalibrationQEPix&) (*fQEs)[pixidx];
-      
-      switch(fCalibrationMode)
+    //
+    // For the moment, we use only a dummy zenith for the calibration:
+    //
+    const Float_t zenith = -1.;
+
+    hiloconv     = 1.;
+    hiloconverr  = 0.;
+    calibConv    = 1.;
+    calibConvVar = 0.;
+    calibFFactor = 0.;
+
+    Float_t calibQE       = 1.;
+    Float_t calibQEVar    = 0.;
+
+    if(fCalibrationMode!=kNone)
+    {
+        MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCalibrations)[pixidx];
+
+        hiloconv   = pix.GetConversionHiLo   ();
+        hiloconverr= pix.GetConversionHiLoErr();
+
+        if (fBadPixels)
+        {
+            MBadPixelsPix &bad = (*fBadPixels)[pixidx];
+            if (bad.IsUnsuitable())
+                return kFALSE;
+        }
+
+        calibConv    = pix.GetMeanConvFADC2Phe();
+        calibConvVar = pix.GetMeanConvFADC2PheVar();
+        calibFFactor = pix.GetMeanFFactorFADC2Phot();
+
+        MCalibrationQEPix &qe  = (MCalibrationQEPix&) (*fQEs)[pixidx];
+
+        switch(fCalibrationMode)
         {
         case kFlatCharge:
-          calibConv        = avMean / pix.GetMean() / fGeomCam->GetPixRatio(pixidx) ;
-          calibConvVar     = (avMeanRelVar + pix.GetMeanRelVar()) * calibConv * calibConv;
-          if (pix.IsFFactorMethodValid())
             {
-              const Float_t convmin1 = qe.GetQECascadesFFactor(zenith)/pix.GetMeanConvFADC2Phe();
-              if (convmin1 > 0)
-                calibFFactor *= TMath::Sqrt(convmin1);
-              else
-                calibFFactor = -1.;
+                MCalibrationChargePix &avpix = (MCalibrationChargePix&)fCalibrations->GetAverageArea(0);
+                calibConv    = avpix.GetMean() / (pix.GetMean() * fGeomCam->GetPixRatio(pixidx));
+                calibConvVar = (avpix.GetMeanRelVar() + pix.GetMeanRelVar()) * calibConv * calibConv;
+                if (pix.IsFFactorMethodValid())
+                {
+                    const Float_t convmin1 = qe.GetQECascadesFFactor(zenith)/pix.GetMeanConvFADC2Phe();
+                    if (convmin1 > 0)
+                        calibFFactor *= TMath::Sqrt(convmin1);
+                    else
+                        calibFFactor = -1.;
+                }
             }
-          break;
+            break;
+
         case kBlindPixel:
-          if (qe.IsBlindPixelMethodValid())
-            {
-              calibQE      = qe.GetQECascadesBlindPixel   ( zenith );
-              calibQEVar   = qe.GetQECascadesBlindPixelVar( zenith );
-            }
-          else
-            return kFALSE;
-          break;
+            if (!qe.IsBlindPixelMethodValid())
+                return kFALSE;
+            calibQE     = qe.GetQECascadesBlindPixel   ( zenith );
+            calibQEVar  = qe.GetQECascadesBlindPixelVar( zenith );
+            break;
+
         case kPinDiode:
-          if (qe.IsPINDiodeMethodValid())
-            {
-              calibQE      = qe.GetQECascadesPINDiode   ( zenith );
-              calibQEVar   = qe.GetQECascadesPINDiodeVar( zenith );
-            }
-          else
-            return kFALSE;
-          break;
+            if (!qe.IsPINDiodeMethodValid())
+                return kFALSE;
+            calibQE     = qe.GetQECascadesPINDiode   ( zenith );
+            calibQEVar  = qe.GetQECascadesPINDiodeVar( zenith );
+            break;
+
         case kFfactor:
-          if (pix.IsFFactorMethodValid())
-            {
-              calibQE      = qe.GetQECascadesFFactor   ( zenith );
-              calibQEVar   = qe.GetQECascadesFFactorVar( zenith );
-            }
-          else
-            return kFALSE;
-          break;
+            if (!pix.IsFFactorMethodValid())
+                return kFALSE;
+            calibQE     = qe.GetQECascadesFFactor   ( zenith );
+            calibQEVar  = qe.GetQECascadesFFactorVar( zenith );
+            break;
+
         case kCombined:
-          if (qe.IsCombinedMethodValid())
-            {
-              calibQE      = qe.GetQECascadesCombined   ( zenith );
-              calibQEVar   = qe.GetQECascadesCombinedVar( zenith );
-            }
-          else
-            return kFALSE;
-          break;
+            if (!qe.IsCombinedMethodValid())
+                return kFALSE;
+            calibQE     = qe.GetQECascadesCombined   ( zenith );
+            calibQEVar  = qe.GetQECascadesCombinedVar( zenith );
+            break;
+
         case kDummy:
-          hiloconv     = 1.;
-          hiloconverr  = 0.;
-          break;
-          
+            hiloconv    = 1.;
+            hiloconverr = 0.;
+            break;
         } /* switch calibration mode */
     } /* if(fCalibrationMode!=kNone) */
-  else
-    {
-      calibConv  = 1./fGeomCam->GetPixRatio(pixidx);
-    }     
-  
-  calibConv    /= calibQE;
-
-  if (calibConv != 0. && calibQE != 0.)
-    {
-      calibConvVar  = calibConvVar/calibConv/calibConv + calibQEVar/calibQE/calibQE;
-      calibConvVar *= calibConv*calibConv;
-    }
-  
-  return kTRUE;
+    else
+    {
+        calibConv  = 1./fGeomCam->GetPixRatio(pixidx);
+    }
+
+    calibConv /= calibQE;
+
+    if (calibConv != 0. && calibQE != 0.)
+    {
+        const Float_t calibConv2 = calibConv*calibConv;
+        calibConvVar  = calibConvVar/calibConv2 + calibQEVar/(calibQE*calibQE);
+        calibConvVar *= calibConv2;
+    }
+
+    return kTRUE;
 }
 
 void MCalibrateData::CalibrateData()
 {
-    UInt_t npix = fSignals->GetSize();
+    const UInt_t npix = fSignals->GetSize();
 
     Float_t hiloconv;
@@ -515,9 +502,8 @@
             continue;
 
-        MExtractedSignalPix &sig = (*fSignals)[pixidx];
-
-        Float_t signal;
+        const MExtractedSignalPix &sig = (*fSignals)[pixidx];
+
+        Float_t signal = 0;
         Float_t signalErr = 0.;
-        Float_t nphot,nphotErr;
 
         if (sig.IsLoGainUsed())
@@ -528,15 +514,10 @@
         else
         {
-            if (sig.GetExtractedSignalHiGain() > 9999.)
-            {
-                signal = 0.;
-                signalErr = 0.;
-            }
-            else
+            if (sig.GetExtractedSignalHiGain() <= 9999.)
                 signal = sig.GetExtractedSignalHiGain();
         }
 
-        nphot    = signal*calibrationConversionFactor;
-        nphotErr = calibFFactor*TMath::Sqrt(TMath::Abs(nphot));
+        const Float_t nphot    = signal*calibrationConversionFactor;
+        const Float_t nphotErr = calibFFactor*TMath::Sqrt(TMath::Abs(nphot));
 
         //