MUON/AliMUONResponseV0.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 $Log$
  18 Revision 1.4  2000/10/25 10:41:52  morsch
  19 IntPH(..): Protec Log against random numbers equal to 0.
  20
  21 Revision 1.3  2000/07/03 11:54:57  morsch
  22 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
  23 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
  24
  25 Revision 1.2  2000/06/15 07:58:48  morsch
  26 Code from MUON-dev joined
  27
  28 Revision 1.1.2.1  2000/06/09 21:33:35  morsch
  29 AliMUONResponse code  from  AliMUONSegResV0.cxx
  30
  31 */
  32
  33 #include "AliMUONResponseV0.h"
  34 #include "AliSegmentation.h"
  35 #include <TMath.h>
  36 #include <TRandom.h>
  37
  38
  39 ClassImp(AliMUONResponseV0)
  40
  41   //__________________________________________________________________________
  42 void AliMUONResponseV0::SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3)
  43 {
  44   // Set to "SqrtKx3" the Mathieson parameter K3 ("fSqrtKx3")
  45   // in the X direction, perpendicular to the wires,
  46   // and derive the Mathieson parameters K2 ("fKx2") and K4 ("fKx4")
  47   // in the same direction
  48   fSqrtKx3 = SqrtKx3;
  49   fKx2 = TMath::Pi() / 2. * (1. - 0.5 * fSqrtKx3);
  50   Float_t cx1 = fKx2 * fSqrtKx3 / 4. / TMath::ATan(Double_t(fSqrtKx3));
  51   fKx4 = cx1 / fKx2 / fSqrtKx3;
  52 }
  53
  54   //__________________________________________________________________________
  55 void AliMUONResponseV0::SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3)
  56 {
  57   // Set to "SqrtKy3" the Mathieson parameter K3 ("fSqrtKy3")
  58   // in the Y direction, along the wires,
  59   // and derive the Mathieson parameters K2 ("fKy2") and K4 ("fKy4")
  60   // in the same direction
  61   fSqrtKy3 = SqrtKy3;
  62   fKy2 = TMath::Pi() / 2. * (1. - 0.5 * fSqrtKy3);
  63   Float_t cy1 = fKy2 * fSqrtKy3 / 4. / TMath::ATan(Double_t(fSqrtKy3));
  64   fKy4 = cy1 / fKy2 / fSqrtKy3;
  65 }
  66
  67 Float_t AliMUONResponseV0::IntPH(Float_t eloss)
  68 {
  69   // Calculate charge from given ionization energy loss
  70   Int_t nel;
  71   nel= Int_t(eloss*1.e9/32.);
  72   Float_t charge=0;
  73   if (nel == 0) nel=1;
  74   for (Int_t i=1;i<=nel;i++) {
  75       Float_t arg=0.;
  76       while(!arg) arg = gRandom->Rndm();
  77       charge -= fChargeSlope*TMath::Log(arg);
  78   }
  79   return charge;
  80 }
  81 // -------------------------------------------
  82
  83 Float_t AliMUONResponseV0::IntXY(AliSegmentation * segmentation)
  84 {
  85 // Calculate charge on current pad according to Mathieson distribution
  86 //
  87     const Float_t kInversePitch = 1/fPitch;
  88 //
  89 //  Integration limits defined by segmentation model
  90 //
  91     Float_t xi1, xi2, yi1, yi2;
  92     segmentation->IntegrationLimits(xi1,xi2,yi1,yi2);
  93     xi1=xi1*kInversePitch;
  94     xi2=xi2*kInversePitch;
  95     yi1=yi1*kInversePitch;
  96     yi2=yi2*kInversePitch;
  97 //
  98 // The Mathieson function
  99     Double_t ux1=fSqrtKx3*TMath::TanH(fKx2*xi1);
 100     Double_t ux2=fSqrtKx3*TMath::TanH(fKx2*xi2);
 101
 102     Double_t uy1=fSqrtKy3*TMath::TanH(fKy2*yi1);
 103     Double_t uy2=fSqrtKy3*TMath::TanH(fKy2*yi2);
 104
 105
 106     return Float_t(4.*fKx4*(TMath::ATan(ux2)-TMath::ATan(ux1))*
 107                       fKy4*(TMath::ATan(uy2)-TMath::ATan(uy1)));
 108 }
 109
 110 Int_t  AliMUONResponseV0::DigitResponse(Int_t digit)
 111 {
 112     // add white noise and do zero-suppression and signal truncation
 113     Float_t meanNoise = gRandom->Gaus(1, 0.2);
 114     Float_t noise     = gRandom->Gaus(0, meanNoise);
 115     digit+=(Int_t)noise;
 116     if ( digit <= ZeroSuppression()) digit = 0;
 117     if ( digit >  MaxAdc())          digit=MaxAdc();
 118     return digit;
 119 }
 120
 121
 122
 123
 124
 125
 126
 127
 128