PHOS/AliPHOSRecCpvManager.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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
  17 //_________________________________________________________________________
  18 // Class for the management by the CPV reconstruction.
  19 ////
  20 //*-- Author   : Boris Polichtchouk (IHEP, Protvino) 6 Mar 2001
  21 //
  22 // --- ROOT system ---
  23
  24 // --- Standard library ---
  25
  26 // --- AliRoot header files ---
  27
  28 #include "AliPHOSRecCpvManager.h"
  29 #include "AliPHOSGetter.h"
  30
  31 ClassImp(AliPHOSRecCpvManager)
  32
  33 //____________________________________________________________________________
  34
  35   AliPHOSRecCpvManager::AliPHOSRecCpvManager()
  36 {
  37   // Put a comment here
  38
  39   fOneGamChisqCut = 3.; // If Chi2/dof > fOneGamChisqCut, split point.
  40
  41   fOneGamInitialStep = 0.00005;
  42   fOneGamChisqMin = 1.;
  43   fOneGamStepMin = 0.0005;
  44   fOneGamNumOfIterations = 50;
  45
  46   fTwoGamInitialStep = 0.00005;
  47   fTwoGamChisqMin = 1.;
  48   fTwoGamEmin = 0.1;
  49   fTwoGamStepMin = 0.00005;
  50   fTwoGamNumOfIterations = 50;
  51
  52 //    fThr0 = 0.0285; // Min. energy of rec. point. If E<fThr0, point deleted.
  53 //    fSqdCut = 3.; // Min. distance (in cm) between two rec points.
  54
  55   fThr0 = 0.;
  56   fSqdCut = 0.;
  57
  58   SetTitle("Cpv Reconstruction Manager");
  59 }
  60
  61 AliPHOSRecCpvManager::~AliPHOSRecCpvManager(void)
  62 {
  63   // Put a comment here
  64 }
  65
  66 Float_t AliPHOSRecCpvManager::Dispersion(Float_t etot, Float_t ai, Float_t ei) const
  67 {
  68   //"Dispresion" of energy deposition in the cell.
  69   // etot is the total shower energy, ai is the
  70   // calculated cell response,
  71   // ei is the measured cell response.
  72
  73   const Float_t kConst = 1.5;
  74   return kConst*ai*(1.-ai/etot);
  75 }
  76
  77 Float_t AliPHOSRecCpvManager::OneGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& Gi) const
  78 {
  79   //"Chi2" for one cell.
  80   // etot is the total "shower" energy, ai is the
  81   // calculated cell response,
  82   // ei is the measured cell response.
  83
  84   const Float_t kConst = 1.5;
  85
  86   Float_t da = ai - ei;
  87   Float_t d = kConst*ai*(1.-ai/etot);
  88
  89   Float_t dd = da/d;
  90   Gi = dd*(2.- dd*kConst*(1.-2.*ai/etot));
  91
  92   Info("OneGamChi2", " OneGamChi2 (ai,ei,etot,&Gi,chi2) %f %f %f %f %f", ai, ei, etot, Gi, da*da/d );
  93
  94   return da*da/d;
  95
  96 }
  97
  98 Float_t AliPHOSRecCpvManager::TwoGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) const
  99 {
 100   // Put a comment here
 101
 102   const Float_t kConst = 1.5;
 103
 104   Float_t da = ai - ei;
 105   Float_t d = kConst*ai*(1.-ai/etot);
 106
 107   Float_t dd = da/d;
 108   gi = dd*(2.- dd*kConst*(1.-2.*ai/etot));
 109
 110   return da*da/d;
 111
 112 }
 113
 114 void AliPHOSRecCpvManager::AG(Float_t ei, Float_t xi, Float_t yi, Float_t& ai, Float_t& gxi, Float_t& gyi )
 115 {
 116   //Calculates amplitude (ai) and gradients (gxi, gyi) of CPV pad response.
 117   //Integrated response (total "shower energy") is e,
 118   //xi and yi are the distances along x and y from reference point
 119   // to the pad center.
 120
 121   AliPHOSGeometry * geom = AliPHOSLoader::GetPHOSGeometry();
 122
 123   Float_t celZ = geom->GetPadSizeZ();
 124   Float_t celY = geom->GetPadSizePhi();
 125
 126 //  //    Info("AG", "celZ: %f celY: %f", celZ, celY) ;
 127
 128   Float_t dx = celZ/2.;
 129   Float_t dy = celY/2.;
 130
 131 //  //    Float_t x = xi*celZ;
 132 //  //    Float_t y = yi*celZ;
 133
 134   Float_t x = xi*celZ;
 135   Float_t y = yi*celY;
 136
 137   Float_t e = ei;
 138
 139   Float_t a = Fcml(x+dx,y+dy) - Fcml(x+dx,y-dy) - Fcml(x-dx,y+dy) + Fcml(x-dx,y-dy);
 140   ai = a*e;
 141
 142
 143   Float_t gx = GradX(x+dx,y+dy) - GradX(x+dx,y-dy) - GradX(x-dx,y+dy) + GradX(x-dx,y-dy);
 144   gxi = gx*e*e;
 145
 146   Float_t gy = GradY(x+dx,y+dy) - GradY(x+dx,y-dy) - GradY(x-dx,y+dy) + GradY(x-dx,y-dy);
 147   gyi = gy*e*e;
 148
 149 }
 150
 151 Float_t AliPHOSRecCpvManager::Fcml(Float_t x, Float_t y)
 152 {
 153   //Cumulative function
 154
 155   const Float_t ka = 1.0;
 156   const Float_t kb = 0.70;
 157
 158   Float_t fff  = TMath::ATan(x*y/(  kb*TMath::Sqrt(  (kb*kb) + x*x+y*y)))
 159     - TMath::ATan(x*y/(3*kb*TMath::Sqrt((3*kb)*(3*kb) + x*x+y*y)))
 160     + TMath::ATan(x*y/(5*kb*TMath::Sqrt((5*kb)*(5*kb) + x*x+y*y)))
 161     - TMath::ATan(x*y/(7*kb*TMath::Sqrt((7*kb)*(7*kb) + x*x+y*y)))
 162     + TMath::ATan(x*y/(9*kb*TMath::Sqrt((9*kb)*(9*kb) + x*x+y*y)));
 163
 164   Float_t fcml = ka*fff/TMath::TwoPi();
 165 //    Info("Fcml", "fcml: %f", fcml) ;
 166   return fcml;
 167
 168 }
 169
 170
 171 Float_t AliPHOSRecCpvManager::GradX(Float_t x, Float_t y)
 172 {
 173   // Put a comment here
 174
 175   const Float_t ka = 1.0;
 176   const Float_t kb = 0.70;
 177
 178   Float_t skv      = kb*kb + x*x + y*y;
 179
 180   Float_t gradient = y*(1.-x*x/skv)*  kb*TMath::Sqrt(skv)/( kb*kb*skv+x*x*y*y)
 181     - y*(1.-x*x/skv)*3*kb*TMath::Sqrt(skv)/((3*kb)*(3*kb)*skv+x*x*y*y)
 182     + y*(1.-x*x/skv)*5*kb*TMath::Sqrt(skv)/((5*kb)*(5*kb)*skv+x*x*y*y)
 183     - y*(1.-x*x/skv)*7*kb*TMath::Sqrt(skv)/((7*kb)*(7*kb)*skv+x*x*y*y)
 184     + y*(1.-x*x/skv)*9*kb*TMath::Sqrt(skv)/((9*kb)*(9*kb)*skv+x*x*y*y);
 185
 186   Float_t grad    = ka*gradient/TMath::TwoPi();
 187   return grad;
 188 }
 189
 190
 191 Float_t AliPHOSRecCpvManager::GradY(Float_t x, Float_t y)
 192 {
 193   // Put a comment here
 194
 195   const Float_t ka = 1.0;
 196   const Float_t kb = 0.70;
 197
 198   Float_t skv      = kb*kb + x*x + y*y;
 199   Float_t gradient = x*(1.-y*y/skv)*  kb*TMath::Sqrt(skv)/( kb*kb*skv+x*x*y*y)
 200     - x*(1.-y*y/skv)*3*kb*TMath::Sqrt(skv)/((3*kb)*(3*kb)*skv+x*x*y*y)
 201     + x*(1.-y*y/skv)*5*kb*TMath::Sqrt(skv)/((5*kb)*(5*kb)*skv+x*x*y*y)
 202     - x*(1.-y*y/skv)*7*kb*TMath::Sqrt(skv)/((7*kb)*(7*kb)*skv+x*x*y*y)
 203     + x*(1.-y*y/skv)*9*kb*TMath::Sqrt(skv)/((9*kb)*(9*kb)*skv+x*x*y*y);
 204
 205   Float_t grad    = ka*gradient/TMath::TwoPi();
 206   return grad;
 207 }
 208
 209