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