Index: /trunk/MagicSoft/Mars/Changelog
===================================================================
--- /trunk/MagicSoft/Mars/Changelog	(revision 3521)
+++ /trunk/MagicSoft/Mars/Changelog	(revision 3522)
@@ -18,4 +18,11 @@
 
                                                  -*-*- END OF LINE -*-*-
+
+ 2004/03/16: Wolfgang Wittek
+
+   * manalysis/MSigmabar.[h,cc]
+     - calculate sigmabar as mean of individual pedestalRMS
+       instead of            sqrt of mean pedestalRMS^2
+
 
  2004/03/16: Oscar Blanch
Index: /trunk/MagicSoft/Mars/manalysis/MSigmabar.cc
===================================================================
--- /trunk/MagicSoft/Mars/manalysis/MSigmabar.cc	(revision 3521)
+++ /trunk/MagicSoft/Mars/manalysis/MSigmabar.cc	(revision 3522)
@@ -100,15 +100,15 @@
     Int_t innerPixels[6];
     Int_t outerPixels[6];
-    Float_t innerSquaredSum[6];
-    Float_t outerSquaredSum[6];
+    Float_t innerSum[6];
+    Float_t outerSum[6];
 
     memset(innerPixels, 0, sizeof(innerPixels));
     memset(outerPixels, 0, sizeof(outerPixels));
-    memset(innerSquaredSum, 0, sizeof(innerSquaredSum));
-    memset(outerSquaredSum, 0, sizeof(outerSquaredSum));
-
-    //
-    // sum up sigma^2 for each sector, separately for inner and outer region;
-    // all pixels are renormalized to the area of pixel 0
+    memset(innerSum, 0, sizeof(innerSum));
+    memset(outerSum, 0, sizeof(outerSum));
+
+    //
+    // sum up sigma/sqrt(area) for each sector, 
+    // separately for inner and outer region;
     //
     // consider all pixels with Cherenkov photon information
@@ -149,5 +149,6 @@
         const MGeomPix &gpix = geom[idx];
 
-        Int_t sector = (Int_t)(atan2(gpix.GetY(),gpix.GetX())*6 / (TMath::Pi()*2));
+        Int_t sector = (Int_t)(atan2(gpix.GetY(),gpix.GetX())*6 
+                       / (TMath::Pi()*2));
         if (sector<0)
             sector+=6;
@@ -163,10 +164,10 @@
         {
             innerPixels[sector]++;
-            innerSquaredSum[sector]+= sigma*sigma * ratio;
+            innerSum[sector]+= sigma * sqrt(ratio);
         }
         else
         {
             outerPixels[sector]++;
-            outerSquaredSum[sector]+= sigma*sigma * ratio;
+            outerSum[sector]+= sigma * sqrt(ratio);
         }
     }
@@ -174,28 +175,22 @@
     fInnerPixels   = 0;
     fOuterPixels   = 0;
-    fSigmabarInner = 0;
-    fSigmabarOuter = 0;
+    Double_t fSumInner = 0;
+    Double_t fSumOuter = 0;
     for (UInt_t i=0; i<6; i++)
     {
-        fSigmabarInner += innerSquaredSum[i];
+        fSumInner      += innerSum[i];
         fInnerPixels   += innerPixels[i];
-        fSigmabarOuter += outerSquaredSum[i];
+        fSumOuter      += outerSum[i];
         fOuterPixels   += outerPixels[i];
     }
 
-    //
-    // this is the sqrt of the average sigma^2;
-    //
-    fSigmabar=fInnerPixels+fOuterPixels<=0?0:sqrt((fSigmabarInner+fSigmabarOuter)/(fInnerPixels+fOuterPixels));
-
-    if (fInnerPixels > 0) fSigmabarInner /= fInnerPixels;
-    if (fOuterPixels > 0) fSigmabarOuter /= fOuterPixels;
-
-    //
-    // this is the sqrt of the average sigma^2
-    // for the inner and outer pixels respectively
-    //
-    fSigmabarInner = sqrt( fSigmabarInner );
-    fSigmabarOuter = sqrt( fSigmabarOuter );
+    if (fInnerPixels > 0) fSigmabarInner = fSumInner / fInnerPixels;
+    if (fOuterPixels > 0) fSigmabarOuter = fSumOuter / fOuterPixels;
+
+    //
+    // this is the average sigma/sqrt(area) (over all pixels)
+    //
+    fSigmabar = (fInnerPixels+fOuterPixels)<=0 ? 0:
+                (fSumInner+fSumOuter)/(fInnerPixels+fOuterPixels);
 
     for (UInt_t i=0; i<6; i++)
@@ -203,13 +198,15 @@
         const Double_t ip  = innerPixels[i];
         const Double_t op  = outerPixels[i];
-        const Double_t iss = innerSquaredSum[i];
-        const Double_t oss = outerSquaredSum[i];
+        const Double_t iss = innerSum[i];
+        const Double_t oss = outerSum[i];
 
         const Double_t sum = ip + op;
-
-        fSigmabarSector[i]      = sum<=0 ? 0 : sqrt((iss+oss)/sum);
-        fSigmabarInnerSector[i] = ip <=0 ? 0 : sqrt(iss/ip);
-        fSigmabarOuterSector[i] = op <=0 ? 0 : sqrt(oss/op);
+        fSigmabarInnerSector[i] = ip <=0 ? 0 :       iss/ip;
+        fSigmabarOuterSector[i] = op <=0 ? 0 :       oss/op;
+        fSigmabarSector[i]      = sum<=0 ? 0 : (iss+oss)/sum;
     }
+
+    //TString opt = "";
+    //Print(opt);
 
   return fSigmabar;