Index: trunk/Mars/mcore/DrsCalib.h
===================================================================
--- trunk/Mars/mcore/DrsCalib.h	(revision 16602)
+++ trunk/Mars/mcore/DrsCalib.h	(revision 16603)
@@ -29,5 +29,10 @@
 
 public:
-    DrsCalibrate() : fNumEntries(0), fNumSamples(0), fNumChannels(0) { }
+    DrsCalibrate() : fNumEntries(0), fNumSamples(0), fNumChannels(0)
+    {
+        fSum.reserve(1024*1440);
+        fSum2.reserve(1024*1440);
+    }
+
     void Reset()
     {
@@ -45,6 +50,6 @@
         fNumSamples  = samples;
 
-        fSum.resize(samples*channels);
-        fSum2.resize(samples*channels);
+        fSum.assign(samples*channels, 0);
+        fSum2.assign(samples*channels, 0);
     }
 
@@ -71,5 +76,5 @@
                 fSum2[abs] += v*v;
             }
-        */
+        }*/
 
         // This version is 2.5 times faster because the compilers optimization
@@ -83,12 +88,11 @@
             const size_t pos = ch*1024;
 
-            const int16_t *pval    = val + pos;
-            const int16_t *end_val = val + 1024;
-
-            int64_t *beg_sum  = fSum.data()  + pos;
-            int64_t *beg_sum2 = fSum2.data() + pos;
-
-            int64_t *psum  = beg_sum  + spos;
-            int64_t *psum2 = beg_sum2 + spos;
+            const int16_t *beg_val  = val          + pos;
+            int64_t       *beg_sum  = fSum.data()  + pos;
+            int64_t       *beg_sum2 = fSum2.data() + pos;
+
+            const int16_t *pval  = beg_val;          // val[rel]
+            int64_t       *psum  = beg_sum  + spos;  // fSum[abs]
+            int64_t       *psum2 = beg_sum2 + spos;  // fSum2[abs]
 
             while (psum<beg_sum+1024)
@@ -96,6 +100,6 @@
                 const int64_t v = *pval++;
 
-                *psum++  = v;
-                *psum2++ = v*v;
+                *psum++  += v;
+                *psum2++ += v*v;
             }
 
@@ -103,10 +107,10 @@
             psum2 = beg_sum2;
 
-            while (pval<end_val)
+            while (pval<beg_val+1024)
             {
                 const int64_t v = *pval++;
 
-                *psum++  = v;
-                *psum2++ = v*v;
+                *psum++  += v;
+                *psum2++ += v*v;
             }
         }
@@ -152,15 +156,14 @@
             const size_t pos = ch*1024;
 
-            const int16_t *pval    = val + pos;
-            const int16_t *end_val = val + 1024;
-
-            const int32_t *beg_offset = offset + pos;
-            const int32_t *poffset    = beg_offset + spos;
-
-            int64_t *beg_sum  = fSum.data()  + pos;
-            int64_t *beg_sum2 = fSum2.data() + pos;
-
-            int64_t *psum     = beg_sum    + spos;
-            int64_t *psum2    = beg_sum2   + spos;
+            const int16_t *beg_val    = val          + pos;
+            const int32_t *beg_offset = offset       + pos;
+            int64_t       *beg_sum    = fSum.data()  + pos;
+            int64_t       *beg_sum2   = fSum2.data() + pos;
+
+
+            const int16_t *pval    = beg_val;            // val[rel]
+            const int32_t *poffset = beg_offset + spos;  // offset[abs]
+            int64_t       *psum    = beg_sum    + spos;  // fSum[abs]
+            int64_t       *psum2   = beg_sum2   + spos;  // fSum2[abs]
 
             while (psum<beg_sum+1024)
@@ -168,6 +171,6 @@
                 const int64_t v = int64_t(*pval++)*scale - *poffset++;
 
-                *psum++  = v;
-                *psum2++ = v*v;
+                *psum++  += v;
+                *psum2++ += v*v;
             }
 
@@ -176,10 +179,10 @@
             poffset = beg_offset;
 
-            while (pval<end_val)
+            while (pval<beg_val+1024)
             {
                 const int64_t v = int64_t(*pval++)*scale - *poffset++;
 
-                *psum++  = v;
-                *psum2++ = v*v;
+                *psum++  += v;
+                *psum2++ += v*v;
             }
         }
@@ -244,5 +247,5 @@
                 fSum2[rel] += v*v;
             }
-        }*/
+            }*/
 
         // This version is 1.5 times faster because the compilers optimization
@@ -256,14 +259,14 @@
             const size_t pos = ch*fNumSamples;
 
-            const int16_t *pval = val + pos;
-
-            const int32_t *beg_offset = offset + ch*1024;
-            const int32_t *poffset    = beg_offset + spos;
-
-            int64_t *beg_sum  = fSum.data()  + pos;
-            int64_t *beg_sum2 = fSum2.data() + pos;
-
-            int64_t *psum     = beg_sum;
-            int64_t *psum2    = beg_sum2;
+            const int32_t *beg_offset = offset       + ch*1024;
+            const int16_t *beg_val    = val          + pos;
+            int64_t *beg_sum          = fSum.data()  + pos;
+            int64_t *beg_sum2         = fSum2.data() + pos;
+
+
+            const int16_t *pval    = beg_val;             // val[rel]
+            const int32_t *poffset = beg_offset + spos;   // offset[abs]
+            int64_t *psum          = beg_sum;             // fSum[rel]
+            int64_t *psum2         = beg_sum2;            // fSum2[rel]
 
             if (spos+fNumSamples>1024)
@@ -273,6 +276,6 @@
                     const int64_t v = int64_t(*pval++)*scale - *poffset++;
 
-                    *psum++  = v;
-                    *psum2++ = v*v;
+                    *psum++  += v;
+                    *psum2++ += v*v;
                 }
 
@@ -284,6 +287,6 @@
                 const int64_t v = int64_t(*pval++)*scale - *poffset++;
 
-                *psum++  = v;
-                *psum2++ = v*v;
+                *psum++  += v;
+                *psum2++ += v*v;
             }
         }
@@ -302,5 +305,4 @@
             return;
         }
-
         /*
         for (size_t i=0; i<roi; i++)
@@ -317,14 +319,14 @@
             const int64_t div = gain[abs];
             vec[i] = div==0 ? 0 : double(v)*scalegain/div;
-        }*/
+        }
+        */
 
         // This version is faster because the compilers optimization
         // is not biased by the evaluation of %1024
         // (Here we are dominated by numerics... improvement ~10%)
-        const int32_t *poffset = offset + start;
-        const int64_t *pgain   = gain   + start;
-        const int16_t *pval    = val;
-
-        float *pvec = vec;
+        const int32_t *poffset = offset + start; // offset[abs]
+        const int64_t *pgain   = gain   + start; // gain[abs]
+        const int16_t *pval    = val;            // val[rel]
+        float         *pvec    = vec;            // vec[rel]
 
         if (start+roi>1024)
@@ -382,13 +384,12 @@
             const int64_t div = gain[abs]*scalerel;
             vec[i] = div==0 ? 0 : double(v)*scalegain/div;
-        }*/
-
+        }
+        */
         // (Here we are dominated by numerics... improvement ~10%)
-        const int32_t *poffset = offset + start;
-        const int64_t *pgain   = gain   + start;
-        const int16_t *pval    = val;
-        const int64_t *ptrgoff = trgoff;
-
-        float *pvec = vec;
+        const int32_t *poffset = offset + start; // offset[abs]
+        const int64_t *pgain   = gain   + start; // gain[abs]
+        const int16_t *pval    = val;            // val[rel]
+        const int64_t *ptrgoff = trgoff;         // trgoff[rel]
+        float         *pvec    = vec;            // vec[rel]
 
         if (start+roi>1024)