FMD/AliFMDMultRegion.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //____________________________________________________________________
  19 //
  20 // FMD reconstructed multiplicity in a region of a ring.  The region
  21 // is identified by (strip_min,sector_min)x(strip_max,sector_max) or
  22 // by (eta_max,phi_min),(eta_min,phi_max).   It's also possible to
  23 // get the peudorapidity of the center-of-mass of the region, as well
  24 // as the mean azimuthal angle.
  25 //
  26 // [Note, that minStrip corresponds to maxEta, and maxStrip
  27 // corresponds to minEta]
  28 //
  29 // These objects are usually created by the Poisson reconstruction
  30 // method.
  31 //
  32 #include "AliFMDMultRegion.h"   // ALIFMDPARTICLES_H
  33 #include <TString.h>            // ROOT_TString
  34 #include <Riostream.h>          // ROOT_Riostream
  35
  36 //____________________________________________________________________
  37 ClassImp(AliFMDMultRegion)
  38 #if 0
  39   ; // This is here to keep Emacs for indenting the next line
  40 #endif
  41
  42
  43 //____________________________________________________________________
  44 AliFMDMultRegion::AliFMDMultRegion()
  45   : fDetector(0),
  46     fRing('\0'),
  47     fMinSector(0),
  48     fMaxSector(0),
  49     fMinStrip(0),
  50     fMaxStrip(0),
  51     fMinEta(0),
  52     fMaxEta(0),
  53     fMinPhi(0),
  54     fMaxPhi(0)
  55 {}
  56
  57 //____________________________________________________________________
  58 AliFMDMultRegion::AliFMDMultRegion(UShort_t detector,  Char_t ring,
  59                                    UShort_t minSector, UShort_t maxSector,
  60                                    UShort_t minStrip,  UShort_t maxStrip,
  61                                    Float_t  minEta,    Float_t  maxEta,
  62                                    Float_t  meanEta,
  63                                    Float_t  minPhi,    Float_t  maxPhi,
  64                                    Float_t  particles, UShort_t method)
  65   : AliFMDMult(particles, method),
  66     fDetector(detector),
  67     fRing(ring),
  68     fMinSector(minSector),
  69     fMaxSector(maxSector),
  70     fMinStrip(minStrip),
  71     fMaxStrip(maxStrip),
  72     fMinEta(minEta),
  73     fMaxEta(maxEta),
  74     fMeanEta(meanEta),
  75     fMinPhi(minPhi),
  76     fMaxPhi(maxPhi)
  77 {}
  78
  79 #if 0
  80 //____________________________________________________________________
  81 Float_t
  82 AliFMDMultRegion::Eta() const
  83 {
  84   // Return the center-of-mass eta of the region.   This is calculated
  85   // as the weighted mean of min and max eta, where the weights are
  86   // the length of the arcs of the upper and lower edge of the region:
  87   //
  88   //            (maxPhi - minPhi)
  89   //  f       = -----------------
  90   //                   360
  91   //
  92   //  w_max   = ds*minStrip*2*pi*f
  93   //
  94   //  w_min   = ds*maxStrip*2*pi*f
  95   //
  96   //  1/w^2   = 1/w_max^2 + 1/w_min^2
  97   //
  98   //                      1                        1
  99   //          = ---------------------- + ----------------------
 100   //            (ds*minStrip*2*pi*f)^2   (ds*maxStrip*2*pi*f)^2
 101   //
 102   //            (ds*maxStrip*2*pi*f)^2 + (ds*minStrip*2*pi*f)^2
 103   //          = -----------------------------------------------
 104   //            (ds*maxStrip*2*pi*f)^2 * (ds*minStrip*2*pi*f)^2
 105   //
 106   //
 107   //             4 * pi^2 * ds^2 * f^2 (maxStrip^2  + minStrip^2)
 108   //          = -------------------------------------------------
 109   //             16 * pi^4 * ds^4 * f^4 minStrip^2 * maxStrip^2
 110   //
 111   //                     (maxStrip^2  + minStrip^2)
 112   //          = -------------------------------------------------
 113   //             4 * pi^2 * ds^2 * f^2 minStrip^2 * maxStrip^2
 114   //
 115   //  <eta> = (maxEta/w_max^2 + minEta /w_min^2) / (1/w^2)
 116   //
 117   //           w_min^2 * maxEta + w_max^2 * minEta
 118   //        = ------------------------------------ / (1/w^2)
 119   //                  w_max^2 * w_min^2
 120   //
 121   //           4*pi^2*ds^2*(maxStrip*maxEta + minStrip*minEta)
 122   //        =  ----------------------------------------------- / (1/w^2)
 123   //               16*pi^4*ds^4*f^4*minStrip^2*maxStrip^2
 124   //
 125   //           maxStrip * maxEta + minStrip * minEta
 126   //        =  -------------------------------------
 127   //           4*pi^2*ds^2*f^2*minStrip^2*maxStrip^2
 128   //
 129   //               4*pi^2*ds^2*f^2*minStrip^2*maxStrip^2
 130   //             * -------------------------------------
 131   //                     maxStrip^2+minStrip^2
 132   //
 133   //           maxStrip * maxEta + minStrip * minEta
 134   //        =  -------------------------------------
 135   //                  maxStrip^2 + minStrip^2
 136   //                                                     _
 137   //                                                    |_|
 138   //
 139   Float_t eta = (fMaxStrip * fMaxEta + fMinStrip * fMinEta)
 140     / (fMaxStrip * fMaxStrip + fMinStrip * fMinStrip);
 141   return eta;
 142 }
 143 #endif
 144
 145 //____________________________________________________________________
 146 void
 147 AliFMDMultRegion::Print(Option_t* option) const
 148 {
 149   // Print information
 150   //
 151   // Options:
 152   //    D:           Detector (default)
 153   //    S:           Sector range
 154   //    T:           Strip range
 155   //    E:           Eta range (default)
 156   //    P:           Phi range (default)
 157   //
 158   TString opt(option);
 159   cout << "FMD Multiplicity in a region: " << fParticles << endl;
 160   if (opt.Contains("D", TString::kIgnoreCase))
 161     cout << "  Detector:      FMD" << fDetector << fRing
 162          << "[" << fMinSector << "-" << fMaxSector
 163          << "," <<  fMinStrip << "-" << fMaxStrip << "]" << endl;
 164   if (opt.Contains("E", TString::kIgnoreCase))
 165     cout << "  Eta range:     [" << fMinEta << "," << fMaxEta << endl;
 166   if (opt.Contains("P", TString::kIgnoreCase))
 167     cout << "  Phi range:     [" << fMinPhi << "," << fMaxPhi << endl;
 168   AliFMDMult::Print(option);
 169 }
 170
 171
 172 //____________________________________________________________________
 173 //
 174 // EOF
 175 //