Fix coding convention violations
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 21 Sep 2007 10:09:38 +0000 (10:09 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 21 Sep 2007 10:09:38 +0000 (10:09 +0000)
28 files changed:
FMD/AliFMDBaseDigit.cxx
FMD/AliFMDDetector.cxx
FMD/AliFMDParameters.cxx
FMD/AliFMDReconstructor.cxx
FMD/flow/AliFMDFlowAxis.cxx
FMD/flow/AliFMDFlowAxis.h
FMD/flow/AliFMDFlowBessel.cxx
FMD/flow/AliFMDFlowBessel.h
FMD/flow/AliFMDFlowBin.cxx
FMD/flow/AliFMDFlowBin.h
FMD/flow/AliFMDFlowBinned1D.cxx
FMD/flow/AliFMDFlowBinned1D.h
FMD/flow/AliFMDFlowBinned2D.cxx
FMD/flow/AliFMDFlowBinned2D.h
FMD/flow/AliFMDFlowEfficiency.cxx
FMD/flow/AliFMDFlowEfficiency.h
FMD/flow/AliFMDFlowEventPlane.cxx
FMD/flow/AliFMDFlowEventPlane.h
FMD/flow/AliFMDFlowHarmonic.cxx
FMD/flow/AliFMDFlowHarmonic.h
FMD/flow/AliFMDFlowResolution.cxx
FMD/flow/AliFMDFlowResolution.h
FMD/flow/AliFMDFlowStat.h
FMD/flow/AliFMDFlowTrue.cxx
FMD/flow/AliFMDFlowTrue.h
FMD/flow/AliFMDFlowUtil.h
FMD/flow/FMDflowLinkDef.h
FMD/flow/TestFlow.C

index bd3e564..5ac0b76 100644 (file)
@@ -65,7 +65,7 @@
 
 #include "AliFMDBaseDigit.h"   // ALIFMDDIGIT_H
 #include "Riostream.h"         // ROOT_Riostream
-#include <TString.h>
+// #include <TString.h>
 // #include <AliLog.h>
 #include "AliFMDDebug.h" // Better debug macros
 
index 70443dd..baa1dd0 100644 (file)
@@ -322,6 +322,10 @@ AliFMDDetector::InitTransformations()
 void
 AliFMDDetector::SetAlignableVolumes() const
 {
+  // Set alignable volumes. 
+  // This will define the alignable volumes. 
+  // That is currently, the modules and the half-rings. 
+  
   AliFMDDebug(10, ("Making alignable volumes for FMD%d", fId));
   if (!gGeoManager) {
     AliFatal("No TGeoManager defined");
index 1aaae30..6ff951a 100644 (file)
@@ -288,24 +288,24 @@ AliFMDParameters::Print(Option_t* option) const
     size_t   i    = opt.Index("fmd",TString::kIgnoreCase);
     size_t   j    = opt.Index("]",TString::kIgnoreCase);
     enum {
-      read_det, 
-      read_ring, 
-      read_lbrack,
-      read_sector,
-      read_comma,
-      read_strip,
-      read_rbrack, 
-      end
-    } state = read_det;
+      kReadDet, 
+      kReadRing, 
+      kReadLbrack,
+      kReadSector,
+      kReadComma,
+      kReadStrip,
+      kReadRbrack, 
+      kEnd
+    } state = kReadDet;
     std::stringstream s(opt(i+4, j-i-3).Data());
-    while (state != end) {
+    while (state != kEnd) {
       Char_t tmp = s.peek();
       if (tmp == ' ' || tmp == '\t') {
        s.get();
        continue;
       }
       switch (state) {
-      case read_det: { // First, try to read the detector 
+      case kReadDet: { // First, try to kRead the detector 
        if (tmp == '*') s.get();
        else { 
          UShort_t det;
@@ -315,23 +315,23 @@ AliFMDParameters::Print(Option_t* option) const
            ds[1] = 0;
          }
        }
-       state = (s.bad() ? end : read_ring);
+       state = (s.bad() ? kEnd : kReadRing);
       } break;
-      case read_ring: { // Then try to read the ring;
+      case kReadRing: { // Then try to read the ring;
        Char_t ring;
        s >> ring;
        if (ring != '*' && !s.bad()) {
          rs[0] = ring;
          rs[1] = '\0';
        }
-       state = (s.bad() ? end : read_lbrack);
+       state = (s.bad() ? kEnd : kReadLbrack);
       } break;
-      case read_lbrack: { // Try to read a left bracket 
+      case kReadLbrack: { // Try to read a left bracket 
        Char_t lbrack;
        s >> lbrack;
-       state = (s.bad() ? end : read_sector);
+       state = (s.bad() ? kEnd : kReadSector);
       } break;
-      case read_sector: { // Try to read a sector 
+      case kReadSector: { // Try to read a sector 
        if (tmp == '*') s.get();
        else {
          UShort_t sec;
@@ -341,14 +341,14 @@ AliFMDParameters::Print(Option_t* option) const
            maxSector = sec + 1;
          }
        }
-       state = (s.bad() ? end : read_comma);
+       state = (s.bad() ? kEnd : kReadComma);
       } break;
-      case read_comma: { // Try to read a left bracket 
+      case kReadComma: { // Try to read a left bracket 
        Char_t comma;
        s >> comma;
-       state = (s.bad() ? end : read_strip);
+       state = (s.bad() ? kEnd : kReadStrip);
       } break;
-      case read_strip: { // Try to read a strip 
+      case kReadStrip: { // Try to read a strip 
        if (tmp == '*') s.get();
        else {
          UShort_t str;
@@ -358,14 +358,14 @@ AliFMDParameters::Print(Option_t* option) const
            maxStrip = str + 1;
          }
        }
-       state = (s.bad() ? end : read_rbrack);
+       state = (s.bad() ? kEnd : kReadRbrack);
       } break;
-      case read_rbrack: { // Try to read a left bracket 
+      case kReadRbrack: { // Try to read a left bracket 
        Char_t rbrack;
        s >> rbrack;
-       state = end;
+       state = kEnd;
       } break;
-      case end: 
+      case kEnd: 
        break;
       }
     }
index ac8d5e1..cd2d474 100644 (file)
@@ -206,6 +206,9 @@ AliFMDReconstructor::ConvertDigits(AliRawReader* reader,
 void 
 AliFMDReconstructor::GetVertex() const
 {
+  // Return the vertex to use. 
+  // This is obtained from the ESD object. 
+  // If not found, a warning is issued.
   fVertexType    = kNoVertex;
   fCurrentVertex = 0;
   if (fESD) {
index dc35464..ab3317d 100644 (file)
@@ -1,15 +1,41 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Implementation of an Axis in a Flow "histogram" */
 #include "flow/AliFMDFlowAxis.h"
 #include <cmath>
 #include <iostream>
 #include <iomanip>
-
+//  Axis object for the 
+//  AliFMDFlowBinned1D and 
+//  AliFMDFlowBinned2D 
+//  "histograms" of  objects 
+//  of class AliFMDFlowBin. 
+//
 //====================================================================
 AliFMDFlowAxis::AliFMDFlowAxis(UShort_t n, Double_t* bins) 
   : fN(n), 
     fBins(0)
 {
+  // Constructor. 
+  // Parameters 
+  //   n    Number of bins 
+  //   bins Bin boundaries (n+1 elements)
   fBins = new Double_t[fN+1];
   for (UInt_t i = 0; i <= fN; i++) fBins[i] = bins[i];
 }
@@ -18,15 +44,23 @@ AliFMDFlowAxis::AliFMDFlowAxis(UShort_t n, Double_t min, Double_t max)
   : fN(n), 
     fBins(0)
 {
+  // Constructor 
+  //   n    Number of bins.
+  //   min  Axis minimum
+  //   max  Axis maximum
   fBins     = new Double_t[fN+1];
   Double_t dx = (max-min)/fN;
   for (UInt_t i = 0; i <= fN; i++) fBins[i] = min + i * dx;
 }
 //____________________________________________________________________
 AliFMDFlowAxis::AliFMDFlowAxis(const AliFMDFlowAxis& other)
-  : fN(other.fN), 
+  : TObject(other), 
+    fN(other.fN), 
     fBins(0)
 {
+  // Copy constructor 
+  // Parameters 
+  //   other   Object to copy from. 
   fBins = new Double_t[fN+1];
   for (UInt_t i = 0; i <= fN; i++) fBins[i] = other.fBins[i];
 }
@@ -34,6 +68,9 @@ AliFMDFlowAxis::AliFMDFlowAxis(const AliFMDFlowAxis& other)
 AliFMDFlowAxis& 
 AliFMDFlowAxis::operator=(const AliFMDFlowAxis& other)
 {
+  // Assignment operator
+  // Parameters 
+  //   other   Object to assign from. 
   if (fBins) delete [] fBins;
   fN    = other.fN;
   fBins = new Double_t[fN+1];
@@ -43,6 +80,9 @@ AliFMDFlowAxis::operator=(const AliFMDFlowAxis& other)
 //____________________________________________________________________
 AliFMDFlowAxis::~AliFMDFlowAxis()
 {
+  // destructor
+  // Parameters 
+  //   none
   if (fBins) delete [] fBins;
   fBins = 0;
 }
@@ -50,6 +90,9 @@ AliFMDFlowAxis::~AliFMDFlowAxis()
 Int_t 
 AliFMDFlowAxis::FindBin(Double_t x) const 
 {
+  // Find a bin corresponding to x 
+  // Param 
+  //    x   Value to find bin number for
   if (x < fBins[0])  return -1;
   if (x > fBins[fN]) return -1;
   UInt_t above, below, middle;
@@ -67,6 +110,9 @@ AliFMDFlowAxis::FindBin(Double_t x) const
 Double_t 
 AliFMDFlowAxis::BinWidth(UShort_t i) const
 {
+  // Width of bin i 
+  // Parameter 
+  //   i   bin number to get width of 
   if (i >= fN) return 0;
   return (fBins[i+1] - fBins[i]);
 }
@@ -74,6 +120,9 @@ AliFMDFlowAxis::BinWidth(UShort_t i) const
 Double_t 
 AliFMDFlowAxis::BinCenter(UShort_t i) const
 {
+  // Center of bin i 
+  // Parameter 
+  //   i   bin number to get center of 
   if (i >= fN) return 0;
   return fBins[i] + BinWidth(i) / 2;
 }
@@ -81,6 +130,9 @@ AliFMDFlowAxis::BinCenter(UShort_t i) const
 Double_t 
 AliFMDFlowAxis::BinLower(UShort_t i) const
 {
+  // Center of bin i 
+  // Parameter 
+  //   i   bin number to get center of 
   if (i >= fN) return 0;
   return fBins[i];
 }
@@ -88,6 +140,9 @@ AliFMDFlowAxis::BinLower(UShort_t i) const
 Double_t 
 AliFMDFlowAxis::BinUpper(UShort_t i) const
 {
+  // Center of bin i 
+  // Parameter 
+  //   i   bin number to get center of 
   if (i >= fN) return 0;
   return fBins[i+1];
 }
@@ -96,12 +151,15 @@ AliFMDFlowAxis::BinUpper(UShort_t i) const
 void
 AliFMDFlowAxis::Print(Option_t*) const
 {
-  std::ios_base::fmtflags old_flags = std::cout.setf(std::ios_base::fixed, 
-                                                    std::ios_base::floatfield);
+  // Print out
+  // Parameter 
+  //   none
+  std::ios_base::fmtflags oldF = std::cout.setf(std::ios_base::fixed, 
+                                               std::ios_base::floatfield);
   for (UShort_t i = 0; i < fN; i++) 
     std::cout << std::setw(5) << BinLower(i) << " - "
              << std::setw(5) << BinUpper(i) << std::endl;
-  std::cout.setf(old_flags, std::ios_base::floatfield);
+  std::cout.setf(oldF, std::ios_base::floatfield);
 }
 
 
index 045bc02..31397ca 100644 (file)
@@ -1,11 +1,34 @@
 // -*- mode: C++ -*-
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration of an Axis in a Flow "histogram" */
-#ifndef FLOW_AXIS_H
-#define FLOW_AXIS_H
+#ifndef ALIFMDFLOWAXIS_H
+#define ALIFMDFLOWAXIS_H
 #ifndef ROOT_TObject
 # include <TObject.h>
 #endif
+//  Axis object for the 
+//  AliFMDFlowBinned1D and 
+//  AliFMDFlowBinned2D 
+//  "histograms" of  objects 
+//  of class AliFMDFlowBin. 
+//
 
 //______________________________________________________
 /** @class AliFMDFlowAxis flow/AliFMDFlowAxis.h <flow/AliFMDFlowAxis.h>
@@ -61,9 +84,9 @@ public:
   void Print(Option_t* option="") const; //*MENU*
 protected:
   /** Number of bins */ 
-  UShort_t fN;
-  /** Borders of the bins */ 
-  Double_t* fBins; //[fN]
+  UShort_t fN; // Number of bins
+  /** Borders of the bins */  
+  Double_t* fBins; //[fN+1] Bin boundaries
   /** Define for ROOT I/O */
   ClassDef(AliFMDFlowAxis,1);
 };  
index 84063a8..89488ba 100644 (file)
@@ -1,3 +1,20 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Implementation of Bessel functions */
 #include "flow/AliFMDFlowBessel.h"
@@ -15,12 +32,17 @@ namespace
       @param n Order 
       @param x Argument 
       @return @f$ envj_n(x)@f$ */
-  Double_t Envj(UInt_t n, Double_t x) { 
+  Double_t Envj(UInt_t n, Double_t x) 
+  { 
+    // Compute 
+    //   1/2 log10(6.28*n) - n log19(1.36 * x / n)
     return .5 * log10(6.28 * n) - n * log10(1.36 * x / n);
   }
   //__________________________________________________________________
   /** Utility function to do loop in Msta1 and Msta2 */ 
-  UInt_t MstaLoop(Int_t n0, Double_t a0, Float_t mp) {
+  UInt_t MstaLoop(Int_t n0, Double_t a0, Float_t mp) 
+  {
+    // Utility function to do loop in Msta1 and Msta2
     Double_t f0 = Envj(n0, a0) - mp;
     Int_t    n1 = n0 + 5;
     Double_t f1 = Envj(n1, a0) - mp;
@@ -42,19 +64,25 @@ namespace
       @param x   Argument to @f$ J_n(x)@f$ 
       @param mp  Value of magnitude @f$ mp@f$ 
       @return The starting point */
-  UInt_t Msta1(Double_t x, UInt_t mp) { 
+  UInt_t Msta1(Double_t x, UInt_t mp) 
+  { 
+    // Determine the starting point for backward recurrence such that
+    // the magnitude of J_n(x) at that point is about 10^{-mp}
     Double_t a0 = fabs(x);
     Int_t    n0 = Int_t(1.1 * a0) + 1;
     return MstaLoop(n0, a0, mp);
   }
   //__________________________________________________________________
   /** Determine the starting point for backward recurrence such that
-      all @f$ J_n(x)@f$ has @a mp significant digits.
+      all @f$J_n(x)@f$ has @a mp significant digits.
       @param x   Argument to @f$ J_n(x)@f$ 
       @param n   Order of @f$ J_n@f$
       @param mp  Number of significant digits 
       @reutnr starting point */
-  UInt_t Msta2(Double_t x, Int_t n, Int_t mp) { 
+  UInt_t Msta2(Double_t x, Int_t n, Int_t mp) 
+  { 
+    // Determine the starting point for backward recurrence such that 
+    // all J_n(x) has mp significant digits. 
     Double_t a0  = fabs(x);
     Double_t hmp = 0.5 * mp;
     Double_t ejn = Envj(n, a0);
@@ -73,8 +101,14 @@ namespace
 }
 //____________________________________________________________________
 void 
-AliFMDFlowBessel::I01(Double_t x, Double_t& bi0, Double_t& di0, Double_t& bi1, Double_t& di1)
+AliFMDFlowBessel::I01(Double_t x, Double_t& bi0, Double_t& di0, 
+                     Double_t& bi1, Double_t& di1)
 {
+  // Compute the modified Bessel functions 
+  // 
+  //   I_0(x) = \sum_{k=1}^\infty (x^2/4)^k}/(k!)^2
+  // 
+  // and I_1(x), and their first derivatives  
   Double_t       x2 =  x * x;
   if (x == 0) { 
     bi0 = 1;
@@ -136,6 +170,8 @@ AliFMDFlowBessel::I01(Double_t x, Double_t& bi0, Double_t& di0, Double_t& bi1, D
 UInt_t 
 AliFMDFlowBessel::Ihalf(Int_t n, Double_t x, Double_t* bi, Double_t* di) 
 {
+  // Compute the modified Bessel functions I_{n/2}(x) and their 
+  // derivatives.  
   typedef Double_t (*fun_t)(Double_t);
   Int_t   p = (n > 0 ? 1     : -1);
   fun_t s = (n > 0 ? &sinh : &cosh);
@@ -200,6 +236,10 @@ AliFMDFlowBessel::Ihalf(Int_t n, Double_t x, Double_t* bi, Double_t* di)
 UInt_t 
 AliFMDFlowBessel::Iwhole(UInt_t in, Double_t x, Double_t* bi, Double_t* di) 
 {
+  // Compute the modified Bessel functions I_n(x) and their
+  // derivatives.  Note, that I_{-n}(x) = I_n(x) and 
+  // dI_{-n}(x)/dx = dI_{n}(x)/dx so this function can be used 
+  // to evaluate I_n for all natural numbers  
   UInt_t mn = in;
   if (x < 1e-100) { 
     for (UInt_t k = 0; k <= in; k++) bi[k] = di[k]  = 0;
@@ -213,7 +253,7 @@ AliFMDFlowBessel::Iwhole(UInt_t in, Double_t x, Double_t* bi, Double_t* di)
 
   if (in <= 1) return 2;
     
-  if (x > 40 and Int_t(in) < Int_t(.25 * x)) { 
+  if (x > 40 && Int_t(in) < Int_t(.25 * x)) { 
     Double_t h0 = bi0;
     Double_t h1 = bi1;
     for (UInt_t k = 2; k <= in; k++) { 
@@ -247,8 +287,12 @@ AliFMDFlowBessel::Iwhole(UInt_t in, Double_t x, Double_t* bi, Double_t* di)
 
 //____________________________________________________________________
 UInt_t 
-AliFMDFlowBessel::Inu(Double_t n1, Double_t n2, Double_t x, Double_t* bi, Double_t* di)
+AliFMDFlowBessel::Inu(Double_t n1, Double_t n2, Double_t x, 
+                     Double_t* bi, Double_t* di)
 {
+  // Compute the modified Bessel functions I_{\nu}(x) and
+  // their derivatives for \nu = n_1, n_1+1, \ldots, n_2 for
+  // and integer n_1, n_2 or any half-integer n_1, n_2. 
   UInt_t  in1 = UInt_t(fabs(n1));
   UInt_t  in2 = UInt_t(fabs(n2));
   UInt_t  nt  = UInt_t(n2 - n1 + 1);
@@ -333,6 +377,11 @@ AliFMDFlowBessel::Inu(Double_t n1, Double_t n2, Double_t x, Double_t* bi, Double
 Double_t 
 AliFMDFlowBessel::I(Double_t n, Double_t x) 
 { 
+  // Compute the modified Bessel function of the first kind 
+  // 
+  //   I_n(x) = (x/2)^n \sum_{k=0}^\infty (x^2/4)^k / (k!\Gamma(n+k+1))
+  // 
+  // for arbirary integer order n 
   Double_t i[2], di[2];
   Inu(n, n, x, i, di);
   return i[0];
@@ -342,6 +391,12 @@ AliFMDFlowBessel::I(Double_t n, Double_t x)
 Double_t 
 AliFMDFlowBessel::DiffI(Double_t n, Double_t x) 
 { 
+  // Compute the derivative of the modified Bessel function of the
+  // first kind 
+  // 
+  //    dI_n(x)/dx = I_{n-1}(x) - n/x I_{n}(x)
+  // 
+  // for arbirary integer order n
   Double_t i[2], di[2];
   Inu(n, n, x, i, di);
   return di[0];
index a1011b2..5cf6c97 100644 (file)
@@ -1,8 +1,25 @@
 // -*- mode: C++ -*-
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration of Bessel functions */
-#ifndef Bessel_h
-#define Bessel_h
+#ifndef ALIFMDFLOWBESSEL_H
+#define ALIFMDFLOWBESSEL_H
 #include <cctype>
 #include <Rtypes.h>
 
index d7edbd9..0fcab04 100644 (file)
@@ -1,5 +1,31 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief implementation of a Bin in a Flow histogram */
+//____________________________________________________________________
+//
+// This contains an of class AliFMDFlowHarmonic and an object of
+// class AliFMDFlowEventPlane to calculate v_n and \Psi_k.  It contain
+// two objects of class AliFMDFlowEventPlane to calculate the
+// sub-event event planes Psi_A, \Psi_B.  It also contain 3 objects of
+// class AliFMDFlowResolution to calculate the event plane angle
+// resolution. 
+//
 #include "flow/AliFMDFlowBin.h"
 #include <cmath>
 #include <iostream>
@@ -7,6 +33,39 @@
 #include <TBrowser.h>
 
 //====================================================================
+AliFMDFlowBin::AliFMDFlowBin(const AliFMDFlowBin& o) 
+  : TObject(o), 
+    fPsi(o.fPsi), 
+    fPsiA(o.fPsiA), 
+    fPsiB(o.fPsiB), 
+    fRes(o.fRes), 
+    fResStar(o.fResStar), 
+    fResTdr(o.fResTdr), 
+    fHarmonic(o.fHarmonic)
+{
+  // Copy constructor 
+  // Parameters: 
+  //    o Object to copy from 
+}
+
+//____________________________________________________________________
+AliFMDFlowBin&
+AliFMDFlowBin::operator=(const AliFMDFlowBin& o) 
+{
+  // Assignment operator 
+  // Parameters: 
+  //    o Object to assign from
+  fPsi      = o.fPsi;
+  fPsiA     = o.fPsiA;
+  fPsiB     = o.fPsiB;
+  fRes      = o.fRes;
+  fResStar  = o.fResStar;
+  fResTdr   = o.fResTdr;
+  fHarmonic = o.fHarmonic;
+  return *this;
+}
+
+//____________________________________________________________________
 void 
 AliFMDFlowBin::Begin() 
 {
@@ -20,6 +79,11 @@ AliFMDFlowBin::Begin()
 void 
 AliFMDFlowBin::AddToEventPlane(Double_t phi, Double_t w, Bool_t a) 
 {
+  // Called to add a contribution to the event plane 
+  // Parameters 
+  //    phi   The angle phi in [0,2pi] 
+  //    w     Weight
+  //    a    If true, add to sub-event A, otherwise to sub-event B.
   fPsi.Add(phi, w);
   if (a) fPsiA.Add(phi, w);
   else   fPsiB.Add(phi, w);
@@ -29,6 +93,12 @@ AliFMDFlowBin::AddToEventPlane(Double_t phi, Double_t w, Bool_t a)
 void 
 AliFMDFlowBin::AddToHarmonic(Double_t phi, Double_t w)
 {
+  // Called to add a contribution to the harmonic. 
+  // Parameters: 
+  //   phi   The angle phi in [0,2pi]
+  //   w     Weight of phi (only used in the calculation of  
+  //         the event plane).
+  // 
   // Disregard the obervation of phi from the event plane angle. 
   Double_t psi   = fPsi.Psi(phi, w);
   fHarmonic.Add(phi, psi);
@@ -38,19 +108,25 @@ AliFMDFlowBin::AddToHarmonic(Double_t phi, Double_t w)
 void 
 AliFMDFlowBin::End()
 {
-  Double_t psi_A = fPsiA.Psi();
-  Double_t psi_B = fPsiB.Psi();
+  // Should be called at the end of an event
+  Double_t psiA = fPsiA.Psi();
+  Double_t psiB = fPsiB.Psi();
 
   // Update the resolutions 
-  fRes.Add(psi_A, psi_B);
-  fResStar.Add(psi_A, psi_B);
-  fResTdr.Add(psi_A, psi_B);
+  fRes.Add(psiA, psiB);
+  fResStar.Add(psiA, psiB);
+  fResTdr.Add(psiA, psiB);
 }
 
 //____________________________________________________________________
 void 
 AliFMDFlowBin::Event(Double_t* phis, Double_t* ws, UInt_t n) 
 { 
+  // Analyse events 
+  // Parameters 
+  //  phis   Array of phi, (phi_1, ..., phi_n)
+  //  ws     Weights (optional)
+  //  n      Size of phis and possibly ws
   Begin();
   
   // Calculate split. 
@@ -72,6 +148,11 @@ AliFMDFlowBin::Event(Double_t* phis, Double_t* ws, UInt_t n)
 Double_t 
 AliFMDFlowBin::Value(CorType t) const
 { 
+  // Get the value in this bin 
+  // Parameters: 
+  //   t  Which type of correction
+  // 
+  // return the value of the harmonic 
   Double_t e;
   return Value(e, t);
 }
@@ -80,6 +161,11 @@ AliFMDFlowBin::Value(CorType t) const
 Double_t 
 AliFMDFlowBin::EValue(CorType t) const 
 { 
+  // Get the value in this bin 
+  // Parameters: 
+  //    t    Which type of correction 
+  // 
+  // return the error on the value of the harmonic 
   Double_t e2;
   Value(e2, t);
   return sqrt(e2);
@@ -89,6 +175,12 @@ AliFMDFlowBin::EValue(CorType t) const
 Double_t 
 AliFMDFlowBin::Value(Double_t& e2, CorType t) const
 { 
+  // Get the value in this bin 
+  // Parameters: 
+  //    e2   On return, the square error. 
+  //    t    Which type  of correction
+  // 
+  // return the value of the harmonic 
   Double_t r, er2;
   r = Correction(er2, t);
   return fHarmonic.Value(r, er2, e2);
@@ -98,13 +190,19 @@ AliFMDFlowBin::Value(Double_t& e2, CorType t) const
 Double_t 
 AliFMDFlowBin::Correction(Double_t& er2, CorType t) const
 {
+  // Get the value in this bin 
+  // Parameters: 
+  //    e2   On return, the square error. 
+  //    t    Which type  of correction
+  // 
+  // return the value of the Correction
   Double_t r = 1;
   UShort_t k = fHarmonic.Order()/fRes.Order();
   switch (t) { 
-  case naive: r = fRes.Correction(k, er2);     break;
-  case star:  r = fResStar.Correction(k, er2); break;
-  case tdr:   r = fResTdr.Correction(k, er2);  break;
-  default:    r = 1; er2 = 0;                  break;
+  case kNaive: r = fRes.Correction(k, er2);     break;
+  case kStar:  r = fResStar.Correction(k, er2); break;
+  case kTdr:   r = fResTdr.Correction(k, er2);  break;
+  default:     r = 1; er2 = 0;                  break;
   }
   return r;
 }
@@ -112,12 +210,15 @@ AliFMDFlowBin::Correction(Double_t& er2, CorType t) const
 //____________________________________________________________________
 void 
 AliFMDFlowBin::Finish() 
-{}
+{
+  // Called at the end of the event
+}
 
 //____________________________________________________________________
 void
 AliFMDFlowBin::Browse(TBrowser* b) 
 {
+  // Browse this item
   b->Add(&fPsi,      "Full event plane");
   b->Add(&fPsiA,     "Sub-event A event plane");
   b->Add(&fPsiB,     "Sub-event A event plane");
@@ -131,20 +232,21 @@ AliFMDFlowBin::Browse(TBrowser* b)
 void 
 AliFMDFlowBin::Print(Option_t*) const
 {
+  // Print information 
   Double_t e2v[4], v[4], r[4], e2r[4];
   const char* names[] = { "Bare", "Naive", "STAR", "TDR" };
-  v[0] = 100 * Value(e2v[0], AliFMDFlowBin::none);
-  v[1] = 100 * Value(e2v[1], AliFMDFlowBin::naive);
-  v[2] = 100 * Value(e2v[2], AliFMDFlowBin::star);
-  v[3] = 100 * Value(e2v[3], AliFMDFlowBin::tdr);
-  r[0] = 100 * Correction(e2r[0], AliFMDFlowBin::none);
-  r[1] = 100 * Correction(e2r[1], AliFMDFlowBin::naive);
-  r[2] = 100 * Correction(e2r[2], AliFMDFlowBin::star);
-  r[3] = 100 * Correction(e2r[3], AliFMDFlowBin::tdr);
+  v[0] = 100 * Value(e2v[0], AliFMDFlowBin::kNone);
+  v[1] = 100 * Value(e2v[1], AliFMDFlowBin::kNaive);
+  v[2] = 100 * Value(e2v[2], AliFMDFlowBin::kStar);
+  v[3] = 100 * Value(e2v[3], AliFMDFlowBin::kTdr);
+  r[0] = 100 * Correction(e2r[0], AliFMDFlowBin::kNone);
+  r[1] = 100 * Correction(e2r[1], AliFMDFlowBin::kNaive);
+  r[2] = 100 * Correction(e2r[2], AliFMDFlowBin::kStar);
+  r[3] = 100 * Correction(e2r[3], AliFMDFlowBin::kTdr);
   
-  std::streamsize         old_prec  = std::cout.precision(3);
-  std::ios_base::fmtflags old_flags = std::cout.setf(std::ios_base::fixed, 
-                                                    std::ios_base::floatfield);
+  std::streamsize         oldP = std::cout.precision(3);
+  std::ios_base::fmtflags oldF = std::cout.setf(std::ios_base::fixed, 
+                                               std::ios_base::floatfield);
   std::cout << "  v" << std::setw(1) << fHarmonic.Order() << ": ";
   for (UInt_t i = 0; i < 4; i++) 
     std::cout << std::setw(6+(i == 0 ? 0 : 6)) << names[i] << ": " 
@@ -153,8 +255,8 @@ AliFMDFlowBin::Print(Option_t*) const
              << std::setw(7) << r[i] << " +/- " 
              << std::setw(7) << 100*sqrt(e2r[i]) << "]\n";
   std::cout << std::flush;
-  std::cout.precision(old_prec);
-  std::cout.setf(old_flags, std::ios_base::floatfield);
+  std::cout.precision(oldP);
+  std::cout.setf(oldF, std::ios_base::floatfield);
 }
 
 
index f40b747..aa49c65 100644 (file)
@@ -1,8 +1,34 @@
 // -*- mode: C++ -*-
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration of a Bin in a Flow "histogram" */
-#ifndef FLOW_BIN_H
-#define FLOW_BIN_H
+//____________________________________________________________________
+//
+// This contains an of class AliFMDFlowHarmonic and an object of
+// class AliFMDFlowEventPlane to calculate v_n and \Psi_k.  It contain
+// two objects of class AliFMDFlowEventPlane to calculate the
+// sub-event event planes Psi_A, \Psi_B.  It also contain 3 objects of
+// class AliFMDFlowResolution to calculate the event plane angle
+// resolution. 
+//
+#ifndef ALIFMDFLOWBIN_H
+#define ALIFMDFLOWBIN_H
 #include <flow/AliFMDFlowEventPlane.h>
 #include <flow/AliFMDFlowHarmonic.h>
 #include <flow/AliFMDFlowResolution.h>
@@ -42,16 +68,18 @@ public:
   /** Correction type */
   enum CorType {
     /** No correction */
-    none, 
+    kNone, 
     /** Naive, using the formulas in Voloshins paper */
-    naive,
+    kNaive,
     /** STARs way */
-    star, 
+    kStar, 
     /** The way used in the TDR */
-    tdr
+    kTdr
   };
-  /** Constructor */
-  AliFMDFlowBin(UShort_t order, UShort_t k=1) 
+  /** Constructor 
+      @param order Order of harmonic. 
+      @param k     Factor of event plane order=k * m */
+  AliFMDFlowBin(UShort_t order=0, UShort_t k=1) 
     : fPsi(order / k), 
       fPsiA(order / k), 
       fPsiB(order / k), 
@@ -60,6 +88,14 @@ public:
       fResTdr(order / k),
       fHarmonic(order) 
   {}
+  /** Copy constructor 
+      @param o Object top copy from */ 
+  AliFMDFlowBin(const AliFMDFlowBin& o);
+  /** Assignment operator
+      @param o Object to assign from 
+      @return Reference to this object */
+  AliFMDFlowBin& operator=(const AliFMDFlowBin& o);
+  
   /** Destructor */
   virtual ~AliFMDFlowBin() {} 
   /** Should be called at the start of an event */ 
@@ -87,21 +123,21 @@ public:
   /** Get the value in this bin 
       @param t  Which type of correction
       @return the value of the harmonic */
-  virtual Double_t Value(CorType t=naive) const;
+  virtual Double_t Value(CorType t=kTdr) const;
   /** Get the value in this bin 
       @param t  Which type of correction 
       @return the error on the value of the harmonic */
-  virtual Double_t EValue(CorType t=naive) const;
+  virtual Double_t EValue(CorType t=kTdr) const;
   /** Get the value in this bin 
       @param e2 On return, the square error. 
       @param t  Which type of correction
       @return the value of the harmonic */
-  virtual Double_t Value(Double_t& e2, CorType t=naive) const;
+  virtual Double_t Value(Double_t& e2, CorType t=kTdr) const;
   /** Get the value in this bin 
       @param e2 On return, the square error. 
       @param t  Which type  of correction
-      @return the value of the harmonic */
-  virtual Double_t Correction(Double_t& e2, CorType t=naive) const;
+      @return the value of the event plane correction */
+  virtual Double_t Correction(Double_t& e2, CorType t=kTdr) const;
   /** Print summary to standard output */ 
   virtual void Print(Option_t* option="") const; //*MENU*
   /** Return true */ 
@@ -117,21 +153,21 @@ public:
 
 protected:
   /** Major event plane */
-  AliFMDFlowEventPlane fPsi;
+  AliFMDFlowEventPlane fPsi; // Major event plane
   /** Sub-event A event plane */
-  AliFMDFlowEventPlane fPsiA;
+  AliFMDFlowEventPlane fPsiA; // Sub-event A event plane
   /** Sub-event B event plane */
-  AliFMDFlowEventPlane fPsiB;
+  AliFMDFlowEventPlane fPsiB; // Sub-event B event plane
   /** Resolution */
-  AliFMDFlowResolution fRes;
+  AliFMDFlowResolution fRes; // Resolution
   /** Resolution */
-  AliFMDFlowResolutionStar fResStar;
+  AliFMDFlowResolutionStar fResStar; // Resolution
   /** Resolution */
-  AliFMDFlowResolutionTDR fResTdr;
+  AliFMDFlowResolutionTDR fResTdr; // Resolution
   /** The harmonic */
-  AliFMDFlowHarmonic fHarmonic;
+  AliFMDFlowHarmonic fHarmonic; // Harmonic
   /** Define for ROOT I/O */
-  ClassDef(AliFMDFlowBin,1);
+  ClassDef(AliFMDFlowBin,1); // A flow analysis 
 };
 
 
index 9e5bc6d..7bed340 100644 (file)
@@ -1,5 +1,30 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Implementation of a 1-dimensional Flow "histogram" */
+//____________________________________________________________________ 
+//
+// A histogram of flow bins.  The axis can by anything
+// (pseudo-rapidity, transvers momentum) - there's no assumption on
+// what is the basis of the histogram.  The method Event can be used
+// to calculate everything in one go.   Alternatively, one can use the
+// methods AddToEventPlane and AddToHarmonic.  See also the example
+// TestFlow.C 
 #include "flow/AliFMDFlowBinned1D.h"
 #include "flow/AliFMDFlowBin.h"
 #include <cmath>
@@ -18,6 +43,11 @@ AliFMDFlowBinned1D::AliFMDFlowBinned1D(UShort_t order,
   : fXAxis(nxbins, xbins),
     fBins(0)
 {
+  // Constructor 
+  // Parameters: 
+  //   Order   Order 
+  //   nxbins   Number of bins 
+  //   xbins    Bin borders 
   UShort_t n = fXAxis.N();
   fBins   = new AliFMDFlowBin*[n];
   for (UInt_t i = 0; i < n; i++) fBins[i]= new AliFMDFlowBin(order);
@@ -27,6 +57,10 @@ AliFMDFlowBinned1D::AliFMDFlowBinned1D(UShort_t order,
                                       const AliFMDFlowAxis& xaxis)
   : fXAxis(xaxis)
 {
+  // Constructor 
+  // Parameters: 
+  //   Order   Order 
+  //   xaxis    X axis object
   UShort_t n = fXAxis.N();
   fBins   = new AliFMDFlowBin*[n];
   for (UInt_t i = 0; i < n; i++) fBins[i]= new AliFMDFlowBin(order);
@@ -36,6 +70,9 @@ AliFMDFlowBinned1D::AliFMDFlowBinned1D(const AliFMDFlowBinned1D& o)
   : TObject(o), 
     fXAxis(o.fXAxis)
 {
+  // Copy constructor 
+  // Parameters: 
+  //   o   Object to copy from 
   UShort_t n = fXAxis.N();
   fBins   = new AliFMDFlowBin*[n];
   for (UInt_t i = 0; i < n; i++) fBins[i]= new AliFMDFlowBin(*(o.fBins[i]));
@@ -44,6 +81,11 @@ AliFMDFlowBinned1D::AliFMDFlowBinned1D(const AliFMDFlowBinned1D& o)
 AliFMDFlowBinned1D&
 AliFMDFlowBinned1D::operator=(const AliFMDFlowBinned1D& o)
 {
+  // Assignment operator
+  // Parameters: 
+  //   o Object to assign from 
+  // 
+  // Returns reference to this object 
   if (fBins) { 
     for (UInt_t i = 0; i < fXAxis.N(); i++) delete fBins[i];
     delete [] fBins;
@@ -58,6 +100,9 @@ AliFMDFlowBinned1D::operator=(const AliFMDFlowBinned1D& o)
 //____________________________________________________________________
 AliFMDFlowBinned1D::~AliFMDFlowBinned1D()
 {
+  // Destructor 
+  // Parameters: 
+  //    none 
   if (fBins) { 
     for (UInt_t i = 0; i < fXAxis.N(); i++) delete fBins[i];
     delete [] fBins;
@@ -68,6 +113,11 @@ AliFMDFlowBinned1D::~AliFMDFlowBinned1D()
 AliFMDFlowBin* 
 AliFMDFlowBinned1D::GetBin(UShort_t i) const
 {
+  // Get the ith bin 
+  // Parameters: 
+  //    i  Bin number 
+  // 
+  // Return pointer to bin, or null. 
   if (i >= fXAxis.N()) return 0;
   return fBins[i];
 }
@@ -75,6 +125,11 @@ AliFMDFlowBinned1D::GetBin(UShort_t i) const
 AliFMDFlowBin* 
 AliFMDFlowBinned1D::GetBin(Double_t x) const
 {
+  // Get the bin that contains x
+  // Parameters: 
+  //    x  X axis value
+  // 
+  // Return pointer to bin, or null. 
   Int_t i = fXAxis.FindBin(x);
   if (i < 0) return 0;
   UShort_t j = i;
@@ -85,24 +140,42 @@ AliFMDFlowBinned1D::GetBin(Double_t x) const
 void 
 AliFMDFlowBinned1D::Begin()
 {
+  // Called at the beginning of an event
+  // Parameters: 
+  //   none
   for (UInt_t i = 0; i < fXAxis.N(); i++) fBins[i]->Begin();
 }
 //____________________________________________________________________
 void 
 AliFMDFlowBinned1D::End()
 {
+  // Called at the end of an event
+  // Parameters: 
+  //   none
   for (UInt_t i = 0; i < fXAxis.N(); i++) fBins[i]->End();
 }
 //____________________________________________________________________
 void 
 AliFMDFlowBinned1D::Finish()
 {
+  // Called at the end of an job
+  // Parameters: 
+  //   none
   for (UInt_t i = 0; i < fXAxis.N(); i++) fBins[i]->Finish();
 }
 //____________________________________________________________________
 Bool_t 
-AliFMDFlowBinned1D::AddToEventPlane(Double_t x, Double_t phi, Double_t w, Bool_t a)
+AliFMDFlowBinned1D::AddToEventPlane(Double_t x, Double_t phi, 
+                                   Double_t w, Bool_t a)
 {
+  // Called to add a contribution to the event plane 
+  // Parameters:
+  //    x   Bin to fill into 
+  //    w   Weight
+  //    phi The angle phi in radians 
+  //    a   If true, add to sub-event A, otherwise sub-event B
+  // 
+  // Return false if x falls outside the defined range, true otherwise
   AliFMDFlowBin* bin = GetBin(x);
   if (!bin) return kFALSE;
   bin->AddToEventPlane(phi, w, a);
@@ -113,6 +186,12 @@ AliFMDFlowBinned1D::AddToEventPlane(Double_t x, Double_t phi, Double_t w, Bool_t
 Bool_t 
 AliFMDFlowBinned1D::AddToHarmonic(Double_t x, Double_t phi)
 {
+  // Called to add a contribution to the harmonic
+  // Parameters: 
+  //    x   Bin to fill into 
+  //    phi The angle phi in radians
+  // 
+  // Return false if x falls outside the defined range, true otherwise
   AliFMDFlowBin* bin = GetBin(x);
   if (!bin) return kFALSE;
   bin->AddToHarmonic(phi);
@@ -123,6 +202,12 @@ AliFMDFlowBinned1D::AddToHarmonic(Double_t x, Double_t phi)
 void 
 AliFMDFlowBinned1D::Event(Double_t* phis, Double_t* xs, Double_t* ws, ULong_t n)
 {
+  // Process a full event. 
+  // Parameters: 
+  //   phis   List of n phi=[0,2pi] angles 
+  //   xs     List of n x values. 
+  //   ws     Weights
+  //   n      Size of phis and xs
   Begin();
   for (UInt_t i = 0; i < n; i++) 
     AddToEventPlane(xs[i], phis[i], (ws ? ws[i] : 1), 
@@ -136,6 +221,7 @@ AliFMDFlowBinned1D::Event(Double_t* phis, Double_t* xs, Double_t* ws, ULong_t n)
 void 
 AliFMDFlowBinned1D::Browse(TBrowser* b)
 {
+  // Browse this object. 
   b->Add(&fXAxis, "xaxis");
   for (UInt_t i = 0; i < fXAxis.N(); i++) 
     b->Add(fBins[i], Form("bin_%03d", i));
@@ -145,13 +231,27 @@ AliFMDFlowBinned1D::Browse(TBrowser* b)
 void 
 AliFMDFlowBinned1D::Draw(Option_t* option)
 {
+  // Draw the distribution of the harmonics or the event plane
+  // resolution. 
+  // Parameters: 
+  //    option     String of options 
+  // 
+  // Options:
+  //    b          Draw bare averages of cos(n(phi-Psi))
+  //    n          Draw harmonic scaled by naive correction
+  //    s          Draw harmonic scaled by STAR correction 
+  //    t          Draw harmonic scaled by TDR correction 
+  //    r          Draw resolution rather than harmonic 
+  // 
+  // If more than one of b, n, s, or t is given, a 2D histogram is
+  // drawn. 
   TString opt(option);
   opt.ToLower();
   const char* names[] = { "Bare", "Naive", "STAR", "TDR" };
-  const AliFMDFlowBin::CorType types[] = { AliFMDFlowBin::none, 
-                                          AliFMDFlowBin::naive, 
-                                          AliFMDFlowBin::star, 
-                                          AliFMDFlowBin::tdr };
+  const AliFMDFlowBin::CorType types[] = { AliFMDFlowBin::kNone, 
+                                          AliFMDFlowBin::kNaive, 
+                                          AliFMDFlowBin::kStar, 
+                                          AliFMDFlowBin::kTdr };
   Bool_t meths[] = { opt.Contains("b"), 
                     opt.Contains("n"),
                     opt.Contains("s"), 
@@ -210,6 +310,14 @@ AliFMDFlowBinned1D::Draw(Option_t* option)
 void 
 AliFMDFlowBinned1D::Print(Option_t* option) const
 {
+  // Print information to standard output. 
+  // Parameters: 
+  //     option    String of options 
+  // 
+  // Options: 
+  //     d         Print details 
+  //     s         Print summary 
+  // 
   TString opt(option);
   opt.ToLower();
   Bool_t det = opt.Contains("d");
@@ -217,23 +325,23 @@ AliFMDFlowBinned1D::Print(Option_t* option) const
   if (det) { 
     for (UShort_t i = 0; i < fXAxis.N(); i++) { 
       Double_t x = fXAxis.BinCenter(i);
-      std::streamsize         old_p = std::cout.precision(3);
-      std::ios_base::fmtflags old_f = std::cout.setf(std::ios_base::fixed, 
+      std::streamsize         oldP = std::cout.precision(3);
+      std::ios_base::fmtflags oldF = std::cout.setf(std::ios_base::fixed, 
                                                     std::ios_base::floatfield);
       std::cout << "x=" << std::setw(5) << x << std::endl;
       fBins[i]->Print();
-      std::cout.precision(old_p);
-      std::cout.setf(old_f, std::ios_base::floatfield);
+      std::cout.precision(oldP);
+      std::cout.setf(oldF, std::ios_base::floatfield);
     }
   }
   
   if (sum) { 
     UInt_t       nType = 4;
     const char*  names[] = { "Bare",    "Naive",    "STAR",    "TDR" };
-    AliFMDFlowBin::CorType types[] = { AliFMDFlowBin::none, 
-                                      AliFMDFlowBin::naive, 
-                                      AliFMDFlowBin::star, 
-                                      AliFMDFlowBin::tdr };
+    AliFMDFlowBin::CorType types[] = { AliFMDFlowBin::kNone, 
+                                      AliFMDFlowBin::kNaive, 
+                                      AliFMDFlowBin::kStar, 
+                                      AliFMDFlowBin::kTdr };
     std::cout << "    x";
     for (UInt_t i = 0; i < nType; i++) 
       std::cout << " | " << std::setw(6+6+5) << names[i];
@@ -242,9 +350,9 @@ AliFMDFlowBinned1D::Print(Option_t* option) const
       std::cout << "-+-" <<  std::setw(6+6+5) << "-";
     std::cout << std::setfill(' ') << std::endl;
     
-    std::streamsize         old_p = std::cout.precision(2);
-    std::ios_base::fmtflags old_f = std::cout.setf(std::ios_base::fixed, 
-                                                  std::ios_base::floatfield);
+    std::streamsize         oldP = std::cout.precision(2);
+    std::ios_base::fmtflags oldF = std::cout.setf(std::ios_base::fixed, 
+                                                 std::ios_base::floatfield);
     for (UShort_t i = 0; i < fXAxis.N(); i++) { 
       Double_t x = fXAxis.BinCenter(i);
       std::cout << std::setprecision(2) << std::setw(5) << x << std::flush;
@@ -257,8 +365,8 @@ AliFMDFlowBinned1D::Print(Option_t* option) const
       }
       std::cout << std::endl;
     }
-    std::cout.precision(old_p);
-    std::cout.setf(old_f, std::ios_base::floatfield);
+    std::cout.precision(oldP);
+    std::cout.setf(oldF, std::ios_base::floatfield);
   }
 }
 
index e65d812..4fa3b2f 100644 (file)
@@ -1,8 +1,33 @@
 // -*- mode: C++ -*-
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration of a 1-dimensional Flow "histogram" */
-#ifndef FLOW_BINNED1D_H
-#define FLOW_BINNED1D_H
+//____________________________________________________________________ 
+//
+// A histogram of flow bins.  The axis can by anything
+// (pseudo-rapidity, transvers momentum) - there's no assumption on
+// what is the basis of the histogram.  The method Event can be used
+// to calculate everything in one go.   Alternatively, one can use the
+// methods AddToEventPlane and AddToHarmonic.  See also the example
+// TestFlow.C 
+#ifndef ALIFMDFLOWBINNED1D_H
+#define ALIFMDFLOWBINNED1D_H
 #include <flow/AliFMDFlowAxis.h>
 
 // Forward declaration 
@@ -19,13 +44,6 @@ class TBrowser;
 class AliFMDFlowBinned1D : public TObject
 {
 public:
-  /** Flags for print */
-  enum {
-    /** Show details */ 
-    details = 0x1, 
-    /** Show summary */ 
-    summary = 0x2
-  };
   /** Constructor 
       @param order    Order of the harmonic
       @param nxbins   Number of X bins.
@@ -91,9 +109,9 @@ public:
   void Browse(TBrowser* b);
 protected:
   /** X axis */ 
-  AliFMDFlowAxis fXAxis;
+  AliFMDFlowAxis fXAxis; // Axis 
   /** Array of the flow objects */ 
-  AliFMDFlowBin** fBins;
+  AliFMDFlowBin** fBins; // Bins 
   /** Define for ROOT I/O */
   ClassDef(AliFMDFlowBinned1D,1);
 };
index fa655c0..12c1bdc 100644 (file)
@@ -1,5 +1,30 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Implementation of a 2-dimensional Flow "histogram" */
+//____________________________________________________________________ 
+//
+// A histogram of flow bins.  The axis can by anything
+// (pseudo-rapidity, transvers momentum) - there's no assumption on
+// what is the basis of the histogram.  The method Event can be used
+// to calculate everything in one go.   Alternatively, one can use the
+// methods AddToEventPlane and AddToHarmonic.  See also the example
+// TestFlow.C 
 #include "flow/AliFMDFlowBinned2D.h"
 #include "flow/AliFMDFlowBin.h"
 #include <cmath>
@@ -15,17 +40,29 @@ AliFMDFlowBinned2D::AliFMDFlowBinned2D(UShort_t order,
     fYAxis(nybins, ybins),
     fBins(0)
 {
+  // Constructor 
+  // Parameters: 
+  //   Order   Order 
+  //   nxbins   Number of X bins 
+  //   xbins    X Bin borders 
+  //   nybins   Number of Y bins 
+  //   ybins    Y Bin borders 
   UInt_t n = fXAxis.N() * fYAxis.N();
   fBins   = new AliFMDFlowBin*[n];
   for (UInt_t i = 0; i < n; i++) fBins[i]= new AliFMDFlowBin(order);
 }
 //____________________________________________________________________
 AliFMDFlowBinned2D::AliFMDFlowBinned2D(UShort_t order, 
-                        const AliFMDFlowAxis&    xaxis, 
-                        const AliFMDFlowAxis&    yaxis)
+                                      const AliFMDFlowAxis&    xaxis, 
+                                      const AliFMDFlowAxis&    yaxis)
   : fXAxis(xaxis), 
     fYAxis(yaxis)
 {
+  // Constructor 
+  // Parameters: 
+  //   Order   Order 
+  //   xaxis    X axis object
+  //   yaxis    Y axis object
   UShort_t n = fXAxis.N() * fYAxis.N();
   fBins   = new AliFMDFlowBin*[n];
   for (UInt_t i = 0; i < n; i++) fBins[i]= new AliFMDFlowBin(order);
@@ -36,6 +73,9 @@ AliFMDFlowBinned2D::AliFMDFlowBinned2D(const AliFMDFlowBinned2D& o)
     fXAxis(o.fXAxis), 
     fYAxis(o.fYAxis)
 {
+  // Copy constructor 
+  // Parameters: 
+  //   o   Object to copy from 
   UShort_t n = fXAxis.N() * fYAxis.N();
   fBins   = new AliFMDFlowBin*[n];
   for (UInt_t i = 0; i < n; i++) fBins[i]= new AliFMDFlowBin(*(o.fBins[i]));
@@ -44,6 +84,11 @@ AliFMDFlowBinned2D::AliFMDFlowBinned2D(const AliFMDFlowBinned2D& o)
 AliFMDFlowBinned2D&
 AliFMDFlowBinned2D::operator=(const AliFMDFlowBinned2D& o)
 {
+  // Assignment operator
+  // Parameters: 
+  //   o Object to assign from 
+  // 
+  // Returns reference to this object 
   if (fBins) { 
     UInt_t n = fXAxis.N() * fYAxis.N();
     for (UInt_t i = 0; i < n; i++) delete fBins[i];
@@ -59,6 +104,9 @@ AliFMDFlowBinned2D::operator=(const AliFMDFlowBinned2D& o)
 //____________________________________________________________________
 AliFMDFlowBinned2D::~AliFMDFlowBinned2D()
 {
+  // Destructor 
+  // Parameters: 
+  //    none 
   if (fBins) { 
     UInt_t n = fXAxis.N() * fYAxis.N();
     for (UInt_t i = 0; i < n; i++) delete fBins[i];
@@ -69,6 +117,12 @@ AliFMDFlowBinned2D::~AliFMDFlowBinned2D()
 AliFMDFlowBin* 
 AliFMDFlowBinned2D::GetBin(UShort_t i, UShort_t j) const
 {
+  // Get the ith,jth bin 
+  // Parameters: 
+  //    i  X Bin number 
+  //    j  Y Bin number 
+  // 
+  // Return pointer to bin, or null. 
   if (i >= fXAxis.N() || j >= fYAxis.N()) return 0;
   return fBins[i * fYAxis.N() + j];
 }
@@ -76,6 +130,12 @@ AliFMDFlowBinned2D::GetBin(UShort_t i, UShort_t j) const
 AliFMDFlowBin* 
 AliFMDFlowBinned2D::GetBin(Double_t x, Double_t y) const
 {
+  // Get the bin that contains x,y
+  // Parameters: 
+  //    x  X axis value
+  //    y  X axis value
+  // 
+  // Return pointer to bin, or null. 
   Int_t i = fXAxis.FindBin(x);
   if (i < 0) return 0;
   Int_t j = fYAxis.FindBin(y);
@@ -88,6 +148,9 @@ AliFMDFlowBinned2D::GetBin(Double_t x, Double_t y) const
 void 
 AliFMDFlowBinned2D::Begin()
 {
+  // Called at the beginning of an event
+  // Parameters: 
+  //   none
   UInt_t n = fXAxis.N() * fYAxis.N();
   for (UInt_t i = 0; i < n; i++) fBins[i]->Begin();
 }
@@ -95,6 +158,9 @@ AliFMDFlowBinned2D::Begin()
 void 
 AliFMDFlowBinned2D::End()
 {
+  // Called at the end of an event
+  // Parameters: 
+  //   none
   UInt_t n = fXAxis.N() * fYAxis.N();
   for (UInt_t i = 0; i < n; i++) fBins[i]->End();
 }
@@ -102,6 +168,9 @@ AliFMDFlowBinned2D::End()
 void 
 AliFMDFlowBinned2D::Finish()
 {
+  // Called at the end of an job
+  // Parameters: 
+  //   none
   UInt_t n = fXAxis.N() * fYAxis.N();
   for (UInt_t i = 0; i < n; i++) fBins[i]->Finish();
 }
@@ -110,6 +179,15 @@ Bool_t
 AliFMDFlowBinned2D::AddToEventPlane(Double_t x, Double_t y, Double_t phi, 
                                Double_t w, Bool_t a)
 {
+  // Called to add a contribution to the event plane 
+  // Parameters:
+  //    x   X Bin value to fill into 
+  //    y   Y Bin value to fill into 
+  //    w   Weight
+  //    phi The angle phi in radians 
+  //    a   If true, add to sub-event A, otherwise sub-event B
+  // 
+  // Return false if (x,y) falls outside the defined range, true otherwise
   AliFMDFlowBin* bin = GetBin(x, y);
   if (!bin) return kFALSE;
   bin->AddToEventPlane(phi, w, a);
@@ -120,6 +198,13 @@ AliFMDFlowBinned2D::AddToEventPlane(Double_t x, Double_t y, Double_t phi,
 Bool_t 
 AliFMDFlowBinned2D::AddToHarmonic(Double_t x, Double_t y, Double_t phi)
 {
+  // Called to add a contribution to the harmonic
+  // Parameters: 
+  //    x   X Bin value to fill into 
+  //    y   Y Bin value to fill into 
+  //    phi The angle phi in radians
+  // 
+  // Return false if (x,y) falls outside the defined range, true otherwise
   AliFMDFlowBin* bin = GetBin(x, y);
   if (!bin) return kFALSE;
   bin->AddToHarmonic(phi);
@@ -131,6 +216,13 @@ void
 AliFMDFlowBinned2D::Event(Double_t* phis, Double_t* xs, Double_t* ys, 
                          Double_t* ws, ULong_t n)
 {
+  // Process a full event. 
+  // Parameters: 
+  //   phis   List of n phi=[0,2pi] angles 
+  //   xs     List of n x values. 
+  //   ys     List of n y values. 
+  //   ws     Weights
+  //   n      Size of phis and xs
   Begin();
   for (UInt_t i = 0; i < n; i++) 
     AddToEventPlane(xs[i], ys[i], phis[i], (ws ? ws[i] : 1), 
@@ -144,6 +236,7 @@ AliFMDFlowBinned2D::Event(Double_t* phis, Double_t* xs, Double_t* ys,
 void 
 AliFMDFlowBinned2D::Browse(TBrowser* b)
 {
+  // Browse this object
   b->Add(&fXAxis, "xaxis");
   b->Add(&fYAxis, "yaxis");
   for (UInt_t i = 0; i < fXAxis.N(); i++) { 
index ad20b92..4d17a03 100644 (file)
@@ -1,8 +1,33 @@
 // -*- mode: C++ -*-
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration of a 2-dimensional Flow "histogram" */
-#ifndef FLOW_BINNED2D_H
-#define FLOW_BINNED2D_H
+//____________________________________________________________________ 
+//
+// A histogram of flow bins.  The axis can by anything
+// (pseudo-rapidity, transvers momentum) - there's no assumption on
+// what is the basis of the histogram.  The method Event can be used
+// to calculate everything in one go.   Alternatively, one can use the
+// methods AddToEventPlane and AddToHarmonic.  See also the example
+// TestFlow.C 
+#ifndef ALIFMDFLOWBINNED2D_H
+#define ALIFMDFLOWBINNED2D_H
 #include <flow/AliFMDFlowAxis.h>
 #include <TObject.h>
 
@@ -83,11 +108,11 @@ public:
   void Browse(TBrowser* b);
 protected:
   /** X axis */ 
-  AliFMDFlowAxis fXAxis;
+  AliFMDFlowAxis fXAxis; // X axis
   /** Y axis */ 
-  AliFMDFlowAxis fYAxis;
+  AliFMDFlowAxis fYAxis; // Y axis
   /** Array of the flow objects */ 
-  AliFMDFlowBin** fBins;
+  AliFMDFlowBin** fBins;  // Bins 
   /** Define for ROOT I/O */
   ClassDef(AliFMDFlowBinned2D,1);
 };
index 150e772..cdd509f 100644 (file)
@@ -1,3 +1,20 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 #include <flow/AliFMDFlowEfficiency.h>
 #include <cmath>
 #include <iostream>
@@ -109,17 +126,17 @@ AliFMDFlowEfficiency::SearchUpper(Double_t low, Int_t k, Int_t n, Double_t c)
   Double_t integral = BetaAB(low, 1, k, n);
   if (integral == c) return 1; // lucky -- this is the solution
   if (integral <  c) return -1;// no solution exists
-  Double_t too_high = 1;         // upper edge estimate
-  Double_t too_low  = low;
-  Double_t test     = 0;
+  Double_t tooHigh = 1;         // upper edge estimate
+  Double_t tooLow  = low;
+  Double_t test    = 0;
 
   // Use a bracket-and-bisect search.  Loop 20 times, to end up with a
   // root guaranteed accurate to better than 0.1%.  
   for (UInt_t i = 0; i < 20; i++) { 
-    test     = 0.5 * (too_low + too_high);
+    test     = 0.5 * (tooLow + tooHigh);
     integral = BetaAB(low, test, k, n);
-    if (integral > c) too_high = test;
-    else              too_low  = test;
+    if (integral > c) tooHigh = test;
+    else              tooLow  = test;
   }
   return test;
 }
@@ -130,17 +147,17 @@ AliFMDFlowEfficiency::SearchLower(Double_t high, Int_t k, Int_t n, Double_t c)
   Double_t integral = BetaAB(0, high, k, n);
   if (integral == c) return 0; // lucky -- this is the solution
   if (integral <  c) return -1;// no solution exists
-  Double_t too_low  = 0;         // lower edge estimate
-  Double_t too_high = high;
+  Double_t tooLow  = 0;         // lower edge estimate
+  Double_t tooHigh = high;
   Double_t test     = 0;
 
   // Use a bracket-and-bisect search.  Loop 20 times, to end up with a
   // root guaranteed accurate to better than 0.1%.  
   for (UInt_t i = 0; i < 20; i++) { 
-    test     = 0.5 * (too_high + too_low);
+    test     = 0.5 * (tooHigh + tooLow);
     integral = BetaAB(test, high, k, n);
-    if (integral > c) too_low  = test;
-    else              too_high = test;
+    if (integral > c) tooLow  = test;
+    else              tooHigh = test;
   }
   return test;
 }
@@ -151,9 +168,9 @@ AliFMDFlowEfficiency::Brent(Double_t ax, Double_t bx, Double_t cx,
                            Double_t& xmin, Int_t k, Int_t n, Double_t c, 
                            Double_t tol)
 {
-  const Int_t    itmax = 100;
-  const Double_t gold  = 0.3819660;
-  const Double_t eps   = 1e-10;
+  const Int_t    kItMax = 100;
+  const Double_t kGold  = 0.3819660;
+  const Double_t kEps   = 1e-10;
   
   Int_t iter;
   Double_t a  = (ax < cx ? ax : cx);
@@ -167,9 +184,9 @@ AliFMDFlowEfficiency::Brent(Double_t ax, Double_t bx, Double_t cx,
   Double_t fv = fw;
   Double_t fx = fv;
   
-  for (iter = 1; iter <= itmax; iter++) { 
+  for (iter = 1; iter <= kItMax; iter++) { 
     Double_t xm   = .5 * (a + b);
-    Double_t tol1 = tol * fabs(x) + eps;
+    Double_t tol1 = tol * fabs(x) + kEps;
     Double_t tol2 = 2 * tol1;
     if (fabs(x - xm) < (tol2 - .5 * (b-a))) {
       xmin = x;
@@ -188,7 +205,7 @@ AliFMDFlowEfficiency::Brent(Double_t ax, Double_t bx, Double_t cx,
          p <= q * (a - x)            || 
          p >= q * (b - x)) {
        e = (x > xm ? a - x : b - x);
-       d = gold * e;
+       d = kGold * e;
       }
       else {
        d        = p / q;
@@ -199,7 +216,7 @@ AliFMDFlowEfficiency::Brent(Double_t ax, Double_t bx, Double_t cx,
     }
     else { 
       e = (x >= xm ? a - x : b - x);
-      d = gold * e;
+      d = kGold * e;
     }
     Double_t u  = (fabs(d) >= tol1 ? x + d : x + sign(tol1, d));
     Double_t fu = Length(u, k, n, c);
index 59bd9f6..5b5a8c4 100644 (file)
@@ -1,6 +1,23 @@
 // -*- mode: C++ -*-
-#ifndef Efficiency_h
-#define Efficiency_h
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+#ifndef ALIFMDFLOWEFFICIENCY_H
+#define ALIFMDFLOWEFFICIENCY_H
 #include <Rtypes.h>
 
 /** @defgroup z_eff Efficiency calculations 
index 69a97f0..6debf09 100644 (file)
@@ -1,5 +1,33 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Implementation of an EventPlane class */
+//____________________________________________________________________
+//
+// Class to determine the event plane 
+// 
+// The event plane is calculated as 
+// 
+//    Psi_n = 1/n * atan((sum_i(w_i sin(n phi_i)))
+//                        sum_i(w_i cos(n phi_i))))
+//
+// where i runs over all observations of phi in an event, and 
+// w_i is the weight of the ith observation of phi
 #include "flow/AliFMDFlowEventPlane.h"
 #include "flow/AliFMDFlowUtil.h"
 #include <TMath.h>
@@ -19,9 +47,36 @@ extern "C"
 #endif
 
 //====================================================================
+AliFMDFlowEventPlane::AliFMDFlowEventPlane(const AliFMDFlowEventPlane& o)
+  : TObject(o), 
+    fSumSinMPhi(o.fSumSinMPhi),
+    fSumCosMPhi(o.fSumCosMPhi),
+    fOrder(o.fOrder),
+    fCache(-1)
+{
+  // copy cosntructor 
+  // Parameters 
+  //   o  Object to copy from. 
+}
+//____________________________________________________________________
+AliFMDFlowEventPlane&
+AliFMDFlowEventPlane::operator=(const AliFMDFlowEventPlane& o)
+{
+  // Assignment operator. 
+  // Parameters: 
+  //  o Object to assign from 
+  fSumSinMPhi = o.fSumSinMPhi;
+  fSumCosMPhi = o.fSumCosMPhi;
+  fOrder      = o.fOrder;
+  fCache      = -1;
+  return *this;
+}
+
+//____________________________________________________________________
 void 
 AliFMDFlowEventPlane::Clear(Option_t*) 
 { 
+  // clear internal variables. 
   fSumSinMPhi = 0;
   fSumCosMPhi = 0;
   fCache      = -1;
@@ -30,6 +85,10 @@ AliFMDFlowEventPlane::Clear(Option_t*)
 void 
 AliFMDFlowEventPlane::Add(Double_t phi, Double_t weight) 
 { 
+  // Add a data point 
+  // Parameters: 
+  //   phi     The angle phi in[0,2pi]
+  //   weight  The weight 
   Double_t a = NormalizeAngle(fOrder * phi);
   Double_t s, c;
   sincos(a, &s, &c);
@@ -42,6 +101,9 @@ AliFMDFlowEventPlane::Add(Double_t phi, Double_t weight)
 Double_t 
 AliFMDFlowEventPlane::Psi() const  
 { 
+  // Get the event plane 
+  // Parameters: 
+  //   none
   if (fCache < 0) fCache = DoPsi(fSumSinMPhi, fSumCosMPhi);
   return fCache;
 }
@@ -49,6 +111,16 @@ AliFMDFlowEventPlane::Psi() const
 Double_t 
 AliFMDFlowEventPlane::Psi(Double_t phi, Double_t w) const  
 { 
+  // Get the event plane angle Psi_k disregarding the contribution
+  // from the observation phi with weight w.  This is to avoid
+  // auto-correlations  
+  // 
+  // Parameters: 
+  //  phi   The observation  phi
+  //  w     The weight w of the obervation. 
+  // 
+  // Returns The event plane angle Psi with out the contribution from
+  // phi_i
   Double_t a = NormalizeAngle(fOrder * phi);
   Double_t s, c;
   sincos(a, &s, &c);
@@ -62,6 +134,10 @@ AliFMDFlowEventPlane::Psi(Double_t phi, Double_t w) const
 Double_t 
 AliFMDFlowEventPlane::DoPsi(Double_t sumsin, Double_t sumcos) const
 {
+  // Calculate the event plane 
+  // Parameters: 
+  //   sumsin    Sum of sines 
+  //   sumcos    Sum of cosines 
   Double_t psi = 0;
   // Make sure we get an angle everywhere 
   if      (sumcos != 0) psi =  atan2(sumsin, sumcos);
index 8258eab..52feffa 100644 (file)
@@ -1,8 +1,36 @@
 // -*- C++ -*- 
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration of an EventPlane class */
-#ifndef FLOW_EVENTPLANE_H
-#define FLOW_EVENTPLANE_H
+//____________________________________________________________________
+//
+// Class to determine the event plane 
+// 
+// The event plane is calculated as 
+// 
+//    Psi_n = 1/n * atan((sum_i(w_i sin(n phi_i)))
+//                        sum_i(w_i cos(n phi_i))))
+//
+// where i runs over all observations of phi in an event, and 
+// w_i is the weight of the ith observation of phi
+#ifndef ALIFMDFLOWEVENTPLANE_H
+#define ALIFMDFLOWEVENTPLANE_H
 #include <TObject.h>
 
 //______________________________________________________
@@ -25,12 +53,19 @@ class AliFMDFlowEventPlane : public TObject
 public:
   /** Constructor 
       @param m Harmonic number */
-  AliFMDFlowEventPlane(UShort_t m) 
+  AliFMDFlowEventPlane(UShort_t m=0) 
     : fSumSinMPhi(0), 
       fSumCosMPhi(0),
       fOrder(m),
       fCache(0)
   { Clear(); }
+  /** Copy constructor. 
+      @param o Object to copy from */ 
+  AliFMDFlowEventPlane(const AliFMDFlowEventPlane& o);
+  /** Assignement operator. 
+      @param o Object to copy from 
+      @return Reference to this */
+  AliFMDFlowEventPlane& operator=(const AliFMDFlowEventPlane& o);
   /** Destructor */
   ~AliFMDFlowEventPlane() {} 
   /** Clear it */
@@ -61,13 +96,13 @@ protected:
       @return @f$ \Psi@f$ */
   Double_t DoPsi(Double_t sumsin, Double_t sumcos) const;
   /** @f$ \sum_i w_i \sin(k \varphi_i)@f$ */
-  Double_t fSumSinMPhi;
+  Double_t fSumSinMPhi; // Sum of contributions 
   /** @f$ \sum_i w_i \cos(k \varphi_i)@f$ */
-  Double_t fSumCosMPhi;
+  Double_t fSumCosMPhi; // Sum of contributions 
   /** Order */
-  UShort_t fOrder;
+  UShort_t fOrder; // Order 
   /** Cache of Psi */
-  mutable Double_t fCache;
+  mutable Double_t fCache; // Cache of calculated value 
   /** Define for ROOT I/O */
   ClassDef(AliFMDFlowEventPlane,1); 
 };
index 68c3c0d..55052db 100644 (file)
@@ -1,13 +1,64 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Implementation of a Harmonic class */
+//____________________________________________________________________
+//
+// Calculate the nth order harmonic. 
+// Input is the phis of the observations,
+// and the resolution of the event plane. 
+// The class derives from AliFMDFlowStat to easy calculating the mean
+// and the square variance of the harmonic. 
 #include "flow/AliFMDFlowHarmonic.h"
 #include "flow/AliFMDFlowUtil.h"
 // #include <cmath>
 
 //====================================================================
+AliFMDFlowHarmonic::AliFMDFlowHarmonic(const AliFMDFlowHarmonic& o)
+  : AliFMDFlowStat(o), 
+    fOrder(o.fOrder)
+{
+  // Copy constructor 
+  // Parameters: 
+  //   o   Object to copy from 
+}
+
+//____________________________________________________________________
+AliFMDFlowHarmonic&
+AliFMDFlowHarmonic::operator=(const AliFMDFlowHarmonic& o)
+{
+  // Assignment operator 
+  // Parameters: 
+  //   o   Object to assign from 
+  // Return reference to this object. 
+  AliFMDFlowStat::operator=(o);
+  fOrder = o.fOrder;
+  return *this;
+}
+
+//____________________________________________________________________
 void 
 AliFMDFlowHarmonic::Add(Double_t phi, Double_t psi) 
 { 
+  // Add a data point. 
+  // Parameters: 
+  //    phi  Angle. 
+  //    psi  Event plane 
   Double_t a       = NormalizeAngle(fOrder * (phi - psi));
   Double_t contrib = cos(a);
   AliFMDFlowStat::Add(contrib);
index 967651c..930f6d2 100644 (file)
@@ -1,8 +1,32 @@
 // -*- mode: C++ -*-
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration of a Harmonic class */
-#ifndef FLOW_HARMONIC_H
-#define FLOW_HARMONIC_H
+//____________________________________________________________________
+//
+// Calculate the nth order harmonic. 
+// Input is the phis of the observations,
+// and the resolution of the event plane. 
+// The class derives from AliFMDFlowStat to easy calculating the mean
+// and the square variance of the harmonic. 
+#ifndef ALIFMDFLOWHARMONIC_H
+#define ALIFMDFLOWHARMONIC_H
 #include <flow/AliFMDFlowStat.h>
 
 /** @defgroup a_basic Basic classes for doing Flow analysis. 
@@ -35,9 +59,17 @@ class AliFMDFlowHarmonic : public AliFMDFlowStat
 public:
   /** Constructor 
       @param n Order of the harmonic */
-  AliFMDFlowHarmonic(UShort_t n) : fOrder(n) {} 
+  AliFMDFlowHarmonic(UShort_t n=0) : fOrder(n) {} 
   /** Destructor */ 
   virtual ~AliFMDFlowHarmonic() {}
+  /** Copy constructor 
+      @param o Object to copy from. */
+  AliFMDFlowHarmonic(const AliFMDFlowHarmonic& o);
+  /** Assignment operator  
+      @param o Object to assign from
+      @return Reference to this object. */
+  AliFMDFlowHarmonic& operator=(const AliFMDFlowHarmonic& o);
+  
   /** Add a data point 
       @param phi The absolute angle @f$ \varphi \in[0,2\pi]@f$ 
       @param psi The event plane angle @f$ \Psi \in[0,2\pi] @f$ */
@@ -52,7 +84,7 @@ public:
   UShort_t Order() const { return fOrder; }
 protected:
   /** the order */ 
-  UShort_t fOrder;
+  UShort_t fOrder; // Order 
   /** Define for ROOT I/O */ 
   ClassDef(AliFMDFlowHarmonic,1);
 };
index 6a327bd..b37d2d9 100644 (file)
@@ -1,5 +1,30 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Implementation of an Resolution class */
+//____________________________________________________________________
+// 
+// Calculate the event plane resolution. 
+// Input is the observed phis. 
+// There's a number of implementations of this. 
+// One is based on a naive interpretation of the Voloshin paper
+// Another is taken from aliroot/PWG2/FLOW 
+// An finally one is based on Ollitraut's article.
 #include "flow/AliFMDFlowResolution.h"
 #include "flow/AliFMDFlowUtil.h"
 #include "flow/AliFMDFlowBessel.h"
 //#include <cmath>
 
 //====================================================================
+AliFMDFlowResolution::AliFMDFlowResolution(const AliFMDFlowResolution& o)
+  : AliFMDFlowStat(o), 
+    fOrder(o.fOrder)
+{
+  // Copy constructor 
+  // Parameters: 
+  //   o   Object to copy from. 
+}
+//____________________________________________________________________
+AliFMDFlowResolution&
+AliFMDFlowResolution::operator=(const AliFMDFlowResolution& o)
+{
+  // Assignment operator 
+  // Parameter: 
+  //   o Object to assign from
+  // 
+  AliFMDFlowStat::operator=(o);
+  fOrder = o.fOrder;
+  return *this;
+}
+//____________________________________________________________________
 void 
 AliFMDFlowResolution::Add(Double_t psiA, Double_t psiB) 
 { 
+  // add data point 
+  // Parameters: 
+  //  psiA   A sub-event plane angle Psi_A in [0,2pi]
+  //  psiB   B sub-event plane angle Psi_B in [0,2pi]
   Double_t diff    = NormalizeAngle(fOrder * (psiA - psiB));
   Double_t contrib = cos(diff);
   AliFMDFlowStat::Add(contrib);
@@ -22,6 +72,9 @@ AliFMDFlowResolution::Add(Double_t psiA, Double_t psiB)
 Double_t 
 AliFMDFlowResolution::Correction(UShort_t k) const 
 { 
+  // Get the correction for harmonic strength of order @a k 
+  //   k  The harminic strenght order to get the correction for
+  // Returns <cos(n(psi - psi_R))>
   Double_t e;
   return Correction(k, e); 
 }
@@ -30,6 +83,11 @@ AliFMDFlowResolution::Correction(UShort_t k) const
 Double_t 
 AliFMDFlowResolution::Correction(UShort_t, Double_t& e2) const 
 { 
+  // Get the correction for harmonic strength of order k 
+  // Parameters: 
+  //  k  The harminic strenght order to get the correction for
+  //  e2 The square error on the correction 
+  // Returns <cos(n(psi - psi_R))>
   e2 = fSqVar / fN;
   return sqrt(2) * sqrt(fabs(fAverage));
 }
@@ -38,6 +96,9 @@ AliFMDFlowResolution::Correction(UShort_t, Double_t& e2) const
 void
 AliFMDFlowResolution::Draw(Option_t* option) 
 {
+  // Draw this corrrection function 
+  // Parameters: 
+  //   option   String of options. Passed to TGraph::Draw
   TGraph* g = new TGraph(100);
   for (UShort_t i = 0; i < g->GetN(); i++) { 
     Double_t x = -1. + 2. / 100 * i;
@@ -57,6 +118,11 @@ AliFMDFlowResolution::Draw(Option_t* option)
 Double_t 
 AliFMDFlowResolutionStar::Correction(UShort_t k, Double_t& e2) const 
 { 
+  // Get the correction for harmonic strength of order k 
+  // Parameters: 
+  //  k  The harminic strenght order to get the correction for
+  //  e2 The square error on the correction 
+  // Returns <cos(n(psi - psi_R))>
   if (k > 4) return 0;
   Double_t delta = 0;
   Double_t chi   = Chi(fAverage, k, delta);
@@ -69,6 +135,9 @@ AliFMDFlowResolutionStar::Correction(UShort_t k, Double_t& e2) const
 Double_t 
 AliFMDFlowResolutionStar::Correction(UShort_t k) const 
 { 
+  // Get the correction for harmonic strength of order @a k 
+  //   k  The harminic strenght order to get the correction for
+  // Returns <cos(n(psi - psi_R))>
   Double_t e;
   return Correction(k, e); 
 }
@@ -77,6 +146,13 @@ Double_t
 AliFMDFlowResolutionStar::Chi(Double_t res, UShort_t k, 
                              Double_t& delta) const 
 {
+  // Get chi
+  // Parameters:
+  //    res    First shot at the resolution. 
+  //    k      Order 
+  //    delta  On return, the last step size in \chi -
+  //           which is taken to be delta chi  
+  // Returns chi
   delta          = 1;
   Double_t chi   = 2;
   Double_t dr    = 0;
@@ -142,6 +218,11 @@ AliFMDFlowResolutionStar::Res(Double_t chi, UShort_t k, Double_t& dr) const
 void
 AliFMDFlowResolutionStar::Draw(Option_t* option) 
 {
+  // Draw this corrrection function 
+  // Parameters: 
+  //   option   String of options. Passed to TGraph::Draw
+  // Options: 
+  //   chi      Draw chi rather than the resolution. 
   TString opt(option);
   opt.ToLower();
   Bool_t chi = opt.Contains("chi");
@@ -186,17 +267,43 @@ AliFMDFlowResolutionStar::Draw(Option_t* option)
 }
 
 //====================================================================
+AliFMDFlowResolutionTDR::AliFMDFlowResolutionTDR(const 
+                                                AliFMDFlowResolutionTDR& o)
+  : AliFMDFlowResolution(o), 
+    fLarge(o.fLarge)
+{}
+//____________________________________________________________________
+AliFMDFlowResolutionTDR&
+AliFMDFlowResolutionTDR::operator=(const AliFMDFlowResolutionTDR& o)
+{
+  // Assignment operator 
+  // Parameter: 
+  //   o Object to assign from
+  // 
+  AliFMDFlowResolution::operator=(o);
+  fLarge = o.fLarge;
+  return *this;
+}
+//____________________________________________________________________
 void 
 AliFMDFlowResolutionTDR::Clear(Option_t*) 
 {
+  // Clear internal variables. 
+  // Parameters: 
+  //   options   Ignored
   fN = 0;
   fLarge = 0;
 }
 //____________________________________________________________________
 void 
-AliFMDFlowResolutionTDR::Add(Double_t psi_a, Double_t psi_b)
+AliFMDFlowResolutionTDR::Add(Double_t psiA, Double_t psiB)
 { 
-  Double_t a = fabs(psi_a - psi_b);
+  // add data point.  If |psi_a - psi_b| >= pi/2 increase large
+  // counter. 
+  // Parameters: 
+  //  psiA   A sub-event plane angle Psi_A in [0,2pi]
+  //  psiB   B sub-event plane angle Psi_B in [0,2pi]
+  Double_t a = fabs(psiA - psiB);
   if (a >= .5 * M_PI) fLarge++;
   fN++;
 }
@@ -236,6 +343,40 @@ Double_t
 AliFMDFlowResolutionTDR::Res(UShort_t k, Double_t y, Double_t echi2, 
                             Double_t& e2) const
 {
+  // The resolution function is 
+  // 
+  //          sqrt(pi) x exp(-x/4) (f1(x^2/4) + f2(x^2/4))
+  //   r(x) = --------------------------------------------
+  //                          2 sqrt(2) 
+  // 
+  //        
+  //        = c x (f1(y) - f2(y))
+  //
+  // where f1 is the modified Bessel function first kind I_{(k-1)/2}, 
+  // and f2 is the modified Bessel function of the first kind
+  // I_{(k+1)/2}, and 
+  // 
+  //          sqrt(pi) exp(-x^2/4) 
+  //      c = --------------------,   y = x^2/4
+  //              2 sqrt(2)
+  // 
+  // The derivative of the resolution function is 
+  //
+  //            c 
+  //    r'(y) = - (4 sqrt(y) (f1'(y) - f2'(y)) - (4 y - 2)(f1(y) - f2(y)))
+  //            2
+  // 
+  //            c                                    r(y)   
+  //          = - (4 sqrt(y) (f1'(y) - f2'(y))) + --------- - sqrt(y) r(y)
+  //           2                                 2 sqrt(y)       
+  // 
+  // Since dI_n(x)/dx = I_(n-1)(x) - n / x I_n(x), and substituting 
+  // f3(y) = I_((k-3)/2)(y) 
+  // 
+  //            c  
+  //    r'(y) = - ((4 - 2 k) f1(y) - (4 y + 2 k) f2(y) + 4 y f3(y))
+  //            2   
+  // 
   // y = chi^2 / 2
   Double_t chi   = sqrt(2 * y);
   Double_t c     = sqrt(M_PI) * exp(-y) / 2;
@@ -254,6 +395,10 @@ AliFMDFlowResolutionTDR::Res(UShort_t k, Double_t y, Double_t echi2,
 Double_t 
 AliFMDFlowResolutionTDR::Correction(UShort_t k) const 
 { 
+  // Get the correction for harmonic strength of order k 
+  // Parameters: 
+  //  k  The harminic strenght order to get the correction for
+  // Returns <cos(n(psi - psi_R))>
   Double_t e;
   return Correction(k, e); 
 }
@@ -351,6 +496,11 @@ AliFMDFlowResolutionTDR::Chi2Over2(Double_t r, Double_t& e2) const
 void
 AliFMDFlowResolutionTDR::Draw(Option_t* option) 
 {
+  // Draw this corrrection function 
+  // Parameters: 
+  //   option   String of options. Passed to TGraph::Draw
+  // Options: 
+  //   chi      Draw chi rather than the resolution. 
   TString opt(option);
   opt.ToLower();
   Bool_t chi = opt.Contains("chi");
index 021231e..1708a4e 100644 (file)
@@ -1,8 +1,30 @@
 // -*- mode: C++ -*-
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration of an Resolution class */
-#ifndef FLOW_RESOLUTION_H
-#define FLOW_RESOLUTION_H
+//____________________________________________________________________
+//
+// Calculate the event plane resolution. 
+// Input is the observed phis. 
+// There's a number of implementations of this. 
+#ifndef ALIFMDFLOWRESOLUTION_H
+#define ALIFMDFLOWRESOLUTION_H
 #include <flow/AliFMDFlowStat.h>
 
 //______________________________________________________
@@ -51,9 +73,15 @@ class AliFMDFlowResolution : public AliFMDFlowStat
 public:
   /** Constructor
       @param n Harmonic order */
-  AliFMDFlowResolution(UShort_t n) : fOrder(n) {}
+  AliFMDFlowResolution(UShort_t n=0) : fOrder(n) {}
   /** Destructor */
   virtual ~AliFMDFlowResolution() {}
+  /** Copy constructor 
+      @param o Object to copy from */ 
+  AliFMDFlowResolution(const AliFMDFlowResolution& o);
+  /** Assignment operator
+      @param o Object to copy from */ 
+  AliFMDFlowResolution& operator=(const AliFMDFlowResolution& o);
   /** add data point 
       @param psiA A sub-event plane angle @f$ \Psi_A \in[0,2\pi]@f$
       @param psiB B sub-event plane angle @f$ \Psi_B \in[0,2\pi]@f$ */
@@ -74,7 +102,7 @@ public:
   virtual void Draw(Option_t* option=""); //*MENU*
 protected:
   /** Order */
-  UShort_t fOrder;
+  UShort_t fOrder; // Order 
   /** Define for ROOT I/O */
   ClassDef(AliFMDFlowResolution,1);
 };
@@ -128,10 +156,9 @@ class AliFMDFlowResolutionStar : public AliFMDFlowResolution
 public:
   /** Constructor
       @param n Harmonic order */
-  AliFMDFlowResolutionStar(UShort_t n) 
-    : AliFMDFlowResolution(n) {}
+  AliFMDFlowResolutionStar(UShort_t n=0) : AliFMDFlowResolution(n) {}
   /** Destructor */
-  ~AliFMDFlowResolutionStar() {}
+  virtual ~AliFMDFlowResolutionStar() {}
   /** Get the correction for harmonic strength of order @a k 
       @param k The harminic strenght order to get the correction for
       @return @f$ \langle\cos(n(\psi_n - \psi_R))\rangle@f$ */ 
@@ -214,9 +241,16 @@ public:
     : AliFMDFlowResolution(n), fLarge(0) {}
   /** DTOR */
   ~AliFMDFlowResolutionTDR() {}
+  /** Copy constructor 
+      @param o  Object to copy from */ 
+  AliFMDFlowResolutionTDR(const AliFMDFlowResolutionTDR& o);
+  /** Assignment operator 
+      @param o  Object to assign from 
+      @return reference to this */ 
+  AliFMDFlowResolutionTDR& operator=(const AliFMDFlowResolutionTDR& o);
   virtual void Clear(Option_t* option="");
   /** add a data  point */
-  virtual void Add(Double_t psi_a, Double_t psi_b);
+  virtual void Add(Double_t psiA, Double_t psiB);
   /** Get the correction for harmonic strength of order @a k 
       @param k The harminic strenght order to get the correction for
       @return @f$ \langle\cos(n(\psi_n - \psi_R))\rangle@f$ */ 
@@ -246,7 +280,7 @@ protected:
       @f] */
   Double_t Res(UShort_t k, Double_t y, Double_t echi2, Double_t& e2) const;
   /** Number of events with large diviation */
-  ULong_t fLarge;
+  ULong_t fLarge; // Number of events with large angle 
   /** Define for ROOT I/O */
   ClassDef(AliFMDFlowResolutionTDR,1);
 };
index 5b1cb0f..7c1684c 100644 (file)
@@ -1,6 +1,23 @@
 // -*- mode: C++ -*- 
-#ifndef FLOW_STAT_H
-#define FLOW_STAT_H
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+#ifndef ALIFMDFLOWSTAT_H
+#define ALIFMDFLOWSTAT_H
 // #include <cmath>
 #include <TMath.h>
 #include <TObject.h>
@@ -35,6 +52,13 @@ class AliFMDFlowStat : public TObject
 public:
   /** Constructor */
   AliFMDFlowStat() : fAverage(0), fSqVar(0), fN(0) {}
+  /** Copy constructor 
+      @param o Object to copy from. */
+  AliFMDFlowStat(const AliFMDFlowStat& o);
+  /** Assuignement operator
+      @param o Object to assign from. 
+      @return Reference to this */
+  AliFMDFlowStat& operator=(const AliFMDFlowStat& o);
   /** Destructor */
   virtual ~AliFMDFlowStat() {}
   /** Reset */
@@ -47,18 +71,65 @@ public:
   Double_t SqVar() const { return fSqVar; } 
   /** Get the number of data points */
   ULong_t N() const { return fN; }
+  /**  Given the two partial sample of the same stocastic variable, of 
+       size @f$ n_1@f$ and @f$ n_2@f$, with averages @f$ m_1@f$ and
+       @f$ m2@f$, and square variances, @f$ s_1^2@f$ and @f$ s_2^2@f$,
+       calculate the full sample average and square variance: 
+       @f[ 
+       m = \frac{n_1 m_1 + n_2 m_2}{n_1 + n_2} 
+       @f] 
+       and 
+       @f[ 
+       s^2 = \frac{n_1 * s_1^2 + n_2 s_2^2}{n_1 + n_2} 
+             + \frac{n_1 n_2 (m_1 - m_2)^2}{(n_1 + n_2)^2}
+       @f]
+       @param o Other statistics object to add 
+       @return Reference to this */
+  AliFMDFlowStat& operator+=(const AliFMDFlowStat& o);
 protected:
   /** Average */
-  Double_t        fAverage;
+  Double_t        fAverage; // Running 
   /** Square variance */
-  Double_t        fSqVar;
+  Double_t        fSqVar; // Square variance 
   /** Number of data points */
-  ULong_t fN;
+  ULong_t fN; // Number of data points
   /** Define for ROOT I/O */
   ClassDef(AliFMDFlowStat,1);
 };
 
 //__________________________________________________________________
+inline 
+AliFMDFlowStat::AliFMDFlowStat(const AliFMDFlowStat& o)
+  : TObject(o), 
+    fAverage(o.fAverage), 
+    fSqVar(o.fSqVar), 
+    fN(o.fN)
+{}
+//__________________________________________________________________
+inline AliFMDFlowStat&
+AliFMDFlowStat::operator=(const AliFMDFlowStat& o)
+{
+  fAverage = o.fAverage;
+  fSqVar   = o.fSqVar;
+  fN       = o.fN;
+  return *this;
+}
+//__________________________________________________________________
+inline AliFMDFlowStat&
+AliFMDFlowStat::operator+=(const AliFMDFlowStat& o)
+{
+  if (fN + o.fN <= 0) return *this;
+  
+  Double_t m = (fN * o.fAverage + o.fN * o.fAverage)/(fN + o.fN);
+  Double_t s = ((fN * o.fSqVar + o.fN * o.fSqVar)/(fN + o.fN)
+               + (TMath::Power(fAverage - o.fAverage, 2) * fN * o.fN) 
+               / TMath::Power(fN + o.fN, 2));
+  fAverage = m;
+  fSqVar   = s;
+  fN       = fN + o.fN;
+  return *this;
+}
+//__________________________________________________________________
 inline void 
 AliFMDFlowStat::Clear(Option_t*) 
 { 
index d85072b..97ffea2 100644 (file)
@@ -1,3 +1,29 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+//____________________________________________________________________
+//
+//  AliFMDFlowTrueBin: 
+//    A specialised AliFMDFlowBin of flow in case the event plane is
+//    well-known.  
+//  AliFMDFlowTrue1D: 
+//    A specialised AliFMDFlowBinned1D histogram in case the event
+//    plane is well-known.   
+//
 #include "flow/AliFMDFlowTrue.h"
 #include "flow/AliFMDFlowUtil.h"
 #include <iostream>
@@ -8,6 +34,9 @@
 void
 AliFMDFlowTrueBin::End()
 {
+  // Called at end of event 
+  // PArameters: 
+  //   none
   Double_t psi  = fPsi.Psi();
   Double_t dpsi = NormalizeAngle(fPsi.Order() * (psi-fPsiR));
   fResReal.Add(cos(dpsi));
@@ -17,6 +46,9 @@ AliFMDFlowTrueBin::End()
 Double_t 
 AliFMDFlowTrueBin::Value(CorType t) const
 { 
+  // Get value of harmonic
+  // PArameters: 
+  //   see AliFMDFlowBin::Value
   Double_t e;
   return Value(e, t);
 }
@@ -24,12 +56,18 @@ AliFMDFlowTrueBin::Value(CorType t) const
 Double_t
 AliFMDFlowTrueBin::Value(Double_t& e2, CorType) const 
 {
+  // Get value of harmonic
+  // PArameters: 
+  //   see AliFMDFlowBin::Value
   return fHarmonic.Value(1, 0, e2);
 }
 //____________________________________________________________________
 Double_t
 AliFMDFlowTrueBin::Correction(Double_t& e2, CorType) const 
 {
+  // Get value of correction
+  // PArameters: 
+  //   see AliFMDFlowBin::Correction
   e2 = fResReal.SqVar() / fResReal.N();
   return fResReal.Average();
 }
@@ -38,12 +76,15 @@ AliFMDFlowTrueBin::Correction(Double_t& e2, CorType) const
 void
 AliFMDFlowTrueBin::Print(Option_t*) const 
 {
+  // Print to standard out
+  // PArameters: 
+  //   see AliFMDFlowBin::Print
   Double_t e2v, e2r;
-  Double_t v   = 100 * Value(e2v, AliFMDFlowBin::none);
-  Double_t r   = 100 * Correction(e2r, AliFMDFlowBin::none);
+  Double_t v   = 100 * Value(e2v, AliFMDFlowBin::kNone);
+  Double_t r   = 100 * Correction(e2r, AliFMDFlowBin::kNone);
 
-  std::streamsize         old_prec  = std::cout.precision(3);
-  std::ios_base::fmtflags old_flags = std::cout.setf(std::ios_base::fixed, 
+  std::streamsize         oldP  = std::cout.precision(3);
+  std::ios_base::fmtflags oldF = std::cout.setf(std::ios_base::fixed, 
                                                     std::ios_base::floatfield);
   std::cout << "  v" << std::setw(1) << fHarmonic.Order() << ":   True: "
            << std::setw(6) << v << " +/- " 
@@ -51,14 +92,17 @@ AliFMDFlowTrueBin::Print(Option_t*) const
            << std::setw(7) << r << " +/- " 
            << std::setw(7) << 100*sqrt(e2r) << "]";
   std::cout << std::endl;
-  std::cout.precision(old_prec);
-  std::cout.setf(old_flags, std::ios_base::floatfield);                               
+  std::cout.precision(oldP);
+  std::cout.setf(oldF, std::ios_base::floatfield);                            
 }
 
 //====================================================================
 AliFMDFlowTrue1D::AliFMDFlowTrue1D(UShort_t order, const AliFMDFlowAxis& xaxis)
   : AliFMDFlowBinned1D(order, xaxis)
 {
+  // Constructor. 
+  // Parameters: 
+  //   see AliFMDFlowBinned1D::AliFMDFlowBinned1D
   // Delete old flow objects, and make new "true" ones. 
   for (UInt_t i = 0; i < xaxis.N(); i++) { 
     delete fBins[i];
@@ -70,6 +114,9 @@ AliFMDFlowTrue1D::AliFMDFlowTrue1D(UShort_t order, const AliFMDFlowAxis& xaxis)
 void
 AliFMDFlowTrue1D::SetPsi(Double_t psi) 
 { 
+  // Set event plane 
+  // Parameters. 
+  //    psi   The true, well-known, event plane angle 
   for (UInt_t i = 0; i < fXAxis.N(); i++) 
     static_cast<AliFMDFlowTrueBin*>(fBins[i])->SetPsi(psi);
 }
@@ -78,6 +125,9 @@ AliFMDFlowTrue1D::SetPsi(Double_t psi)
 void 
 AliFMDFlowTrue1D::Print(Option_t* option) const
 {
+  // Print to standard out. 
+  // Parameters 
+  //   See AliFMDFlowBinned1D::Print
   TString opt(option);
   opt.ToLower();
   Bool_t det = opt.Contains("d");
@@ -87,21 +137,21 @@ AliFMDFlowTrue1D::Print(Option_t* option) const
     std::cout << "    x |              Real \n" 
              << "------+-------------------" << std::endl;
 
-    std::streamsize         old_p = std::cout.precision(2);
-    std::ios_base::fmtflags old_f = std::cout.setf(std::ios_base::fixed, 
-                                                  std::ios_base::floatfield);
+    std::streamsize         oldP = std::cout.precision(2);
+    std::ios_base::fmtflags oldF = std::cout.setf(std::ios_base::fixed, 
+                                                 std::ios_base::floatfield);
     for (UShort_t i = 0; i < fXAxis.N(); i++) { 
       Double_t x   = fXAxis.BinCenter(i);
       Double_t e2v;
-      Double_t v   = fBins[i]->Value(e2v, AliFMDFlowBin::none);
+      Double_t v   = fBins[i]->Value(e2v, AliFMDFlowBin::kNone);
       std::cout << std::setprecision(2) << std::setw(5) << x << " | " 
                << std::setprecision(3) 
                << std::setw(6) << 100 * v << " +/- " 
                << std::setw(6) << 100 * sqrt(e2v) 
                << std::endl; 
     }
-    std::cout.precision(old_p);
-    std::cout.setf(old_f, std::ios_base::floatfield);
+    std::cout.precision(oldP);
+    std::cout.setf(oldF, std::ios_base::floatfield);
   }
 }
 
index 1da887e..f106d56 100644 (file)
@@ -1,9 +1,35 @@
 // -*- mode: C++ -*-
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 /** @file 
     @brief Declaration and implementation of classes to deal with a
     well-known event plane @f$ \Psi_R@f$. */
-#ifndef FLOW_TRUE_H
-#define FLOW_TRUE_H
+//____________________________________________________________________
+//
+//  AliFMDFlowTrueBin: 
+//    A specialised AliFMDFlowBin of flow in case the event plane is
+//    well-known.  
+//  AliFMDFlowTrue1D: 
+//    A specialised AliFMDFlowBinned1D histogram in case the event
+//    plane is well-known.   
+//
+#ifndef ALIFMDFLOWTRUE_H
+#define ALIFMDFLOWTRUE_H
 #include <flow/AliFMDFlowStat.h>
 #include <flow/AliFMDFlowBin.h>
 #include <flow/AliFMDFlowBinned1D.h>
@@ -15,8 +41,9 @@
     @brief A specialised Bin of flow in case the event plane is 
     well-known. 
     @ingroup x_true */
-struct AliFMDFlowTrueBin : public AliFMDFlowBin
+class AliFMDFlowTrueBin : public AliFMDFlowBin
 {
+public:
   /** Constructor */ 
   AliFMDFlowTrueBin(UShort_t order) : 
     AliFMDFlowBin(order, 1), 
@@ -37,23 +64,24 @@ struct AliFMDFlowTrueBin : public AliFMDFlowBin
   /** Get the value in this bin 
       @param t  Which type of correction
       @return the value of the harmonic */
-  virtual Double_t Value(CorType t=naive) const;
+  virtual Double_t Value(CorType t=kNone) const;
   /** Get the value in this bin 
       @param e2 On return, the square error. 
       @param t  Which type of correction
       @return the value of the harmonic */
-  Double_t Value(Double_t& e2, CorType t=naive) const;
+  Double_t Value(Double_t& e2, CorType t=kNone) const;
   /** Get the value in this bin 
       @param e2 On return, the square error. 
       @param t  Which type  of correction
       @return the value of the harmonic */
-  Double_t Correction(Double_t& e2, CorType t=naive) const;
+  Double_t Correction(Double_t& e2, CorType t=kNone) const;
   /** Print to standard out. */ 
   void Print(Option_t* option="s") const;
+protected:
   /** The well-known event plane */ 
-  Double_t fPsiR; 
+  Double_t fPsiR;  // The well-known event plane 
   /** True resolution */ 
-  AliFMDFlowStat fResReal;
+  AliFMDFlowStat fResReal; // True resolution
   /** define for ROOT I/O */
   ClassDef(AliFMDFlowTrueBin,1);
   
@@ -63,6 +91,7 @@ struct AliFMDFlowTrueBin : public AliFMDFlowBin
     @ingroup x_true */
 struct AliFMDFlowTrue1D : public AliFMDFlowBinned1D
 {
+public:
   /** Constructor */ 
   AliFMDFlowTrue1D(UShort_t order, const AliFMDFlowAxis& xaxis);
   /** Set the well-known event plane angle @f$ \Psi_R@f$ for this
index 81d76f8..81a6da3 100644 (file)
@@ -1,6 +1,23 @@
 // -*- mode: C++ -*-
-#ifndef FLOW_UTIL_H
-#define FLOW_UTIL_H
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+#ifndef ALIFMDFLOWUTIL_H
+#define ALIFMDFLOWUTIL_H
 #include <cmath>
 #ifndef M_PI
 # define M_PI 3.14159265358979323846264338327
index c6a12d6..5681202 100644 (file)
@@ -1,8 +1,22 @@
 // -*- mode: c++ -*- 
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 #ifdef __CINT__
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
 /* $Id$ */
 /** @file    FMDbaseLinkDef.h
     @author  Christian Holm Christensen <cholm@nbi.dk>
index fd1b471..748a059 100644 (file)
@@ -1,3 +1,38 @@
+/* Copyright (C) 2007 Christian Holm Christensen <cholm@nbi.dk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+//___________________________________________________________________
+/** @file 
+    @brief Example 
+    
+    Compile and run like 
+    @verbatim 
+    Root> gSystem->Load("libFMDflow.so");
+    Root> gSystem->AddIncludePath("-I$ALICE_ROOT/FMD")
+    Root> .x FMD/flow/TestFlow.C 
+    @endverbatim 
+
+    or 
+    @verbatim 
+    $ g++ `root-config --cflags --libs` -I$ALICE_ROOT/include \
+       -I$ALICE_ROOT/FMD $ALICE_ROOT/FMD/flow/TestFlow.C -o testflow
+    $ ./testflow 
+    @endverbatim 
+*/
 #include <FMD/flow/AliFMDFlowBinned1D.h>
 #include <FMD/flow/AliFMDFlowTrue.h>
 #include <FMD/flow/AliFMDFlowUtil.h>
 #include <TStyle.h>
 
 //____________________________________________________________________
+/** Generate events */
 struct Generator 
 {
+  /** Constructor 
+      @param psi Possibly fixed event plane (if <0 -> random)
+      @param v1  value of v1 
+      @param v2  value of v2 
+      @param min Minimum number of observations
+      @param max Maximum number of observations */
   Generator(Double_t psi=-1, 
            Double_t v1=.05,  Double_t v2=.05, 
            UInt_t   min=100, UInt_t   max=1000) 
     : fPsi(psi), fV1(v1), fV2(v2), fMin(min), fMax(max) 
   {}
+  /** Prepare for the next event. 
+      @return Number of observations */
   UInt_t Prepare() 
   {
     // Generate a uniform random direction 
@@ -27,6 +71,7 @@ struct Generator
     else           fPsiR = gRandom->Uniform(0, 2 * TMath::Pi());
     return unsigned(gRandom->Uniform(fMin, fMax));
   }
+  /** Create an observation */
   Double_t operator()() 
   {
     // Generate a uniform random direction 
@@ -37,6 +82,7 @@ struct Generator
     phi           += dphi;
     return phi;
   }
+  /** Get the event plane */
   Double_t Psi() const { return fPsiR; }
   Double_t fPsi;
   Double_t fPsiR;
@@ -47,6 +93,7 @@ struct Generator
   UInt_t   fN;
 };
 
+/** Run test program */
 void
 TestFlow(UInt_t n_events=100, Int_t seg=-1, UInt_t n_max=20000)
 {
@@ -118,7 +165,7 @@ TestFlow(UInt_t n_events=100, Int_t seg=-1, UInt_t n_max=20000)
 
 #ifndef __CINT__
 #include <TApplication.h>
-
+/** Entry point for test program */
 int
 main()
 {