Line data    Source code

       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 AliMUONMathieson
      20             : // -----------------------
      21             : // Implementation of Mathieson response
      22             : // Separated from other classes by CH. Finck with removing circular
      23             : // dependencies 
      24             : //-----------------------------------------------------------------------------
      25             : 
      26             : #include "AliMUONMathieson.h"
      27             : 
      28             : #include "AliLog.h"
      29             : 
      30             : #include <TClass.h>
      31             : #include <TMath.h>
      32             : #include <TRandom.h>
      33             : 
      34             : /// \cond CLASSIMP
      35          18 : ClassImp(AliMUONMathieson)
      36             : /// \endcond
      37             :         
      38             : //__________________________________________________________________________
      39         406 : AliMUONMathieson::AliMUONMathieson() :
      40         406 :     fSqrtKx3(0.),
      41         406 :     fKx2(0.),
      42         406 :     fKx4(0.),
      43         406 :     fSqrtKy3(0.),
      44         406 :     fKy2(0.),
      45         406 :     fKy4(0.),
      46         406 :     fPitch(0.),
      47         406 :     fInversePitch(0.)
      48        2030 : {
      49             : /// Default constructor
      50             : 
      51         812 : }
      52             : 
      53             : //__________________________________________________________________________
      54             : AliMUONMathieson::~AliMUONMathieson()
      55        1624 : {
      56             : /// Destructor
      57        1624 : }
      58             : 
      59             :   //__________________________________________________________________________
      60             : void AliMUONMathieson::SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3)
      61             : {
      62             : /// Set to "SqrtKx3" the Mathieson parameter K3 ("fSqrtKx3")
      63             : /// in the X direction, perpendicular to the wires,
      64             : /// and derive the Mathieson parameters K2 ("fKx2") and K4 ("fKx4")
      65             : /// in the same direction
      66         292 :   fSqrtKx3 = SqrtKx3;
      67         146 :   fKx2 = TMath::Pi() / 2. * (1. - 0.5 * fSqrtKx3);
      68         146 :   Float_t cx1 = fKx2 * fSqrtKx3 / 4. / TMath::ATan(Double_t(fSqrtKx3));
      69         146 :   fKx4 = cx1 / fKx2 / fSqrtKx3;
      70         146 : }
      71             :         
      72             :   //__________________________________________________________________________
      73             : void AliMUONMathieson::SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3)
      74             : {
      75             : /// Set to "SqrtKy3" the Mathieson parameter K3 ("fSqrtKy3")
      76             : /// in the Y direction, along the wires,
      77             : /// and derive the Mathieson parameters K2 ("fKy2") and K4 ("fKy4")
      78             : /// in the same direction
      79         292 :   fSqrtKy3 = SqrtKy3;
      80         146 :   fKy2 = TMath::Pi() / 2. * (1. - 0.5 * fSqrtKy3);
      81         146 :   Float_t cy1 = fKy2 * fSqrtKy3 / 4. / TMath::ATan(Double_t(fSqrtKy3));
      82         146 :   fKy4 = cy1 / fKy2 / fSqrtKy3;
      83         146 : }
      84             : 
      85             : //_____________________________________________________________________________
      86             : Float_t
      87             : AliMUONMathieson::IntXY(Float_t xi1, Float_t yi1, Float_t xi2, Float_t yi2) const
      88             : {
      89             : /// Integrate the Mathieson over x and y
      90             : 
      91      100604 :   xi1 *= fInversePitch;
      92       50302 :   xi2 *= fInversePitch;
      93       50302 :   yi1 *= fInversePitch;
      94       50302 :   yi2 *= fInversePitch;
      95             :   //
      96             :   // The Mathieson function 
      97       50302 :   Double_t ux1=fSqrtKx3*TMath::TanH(fKx2*xi1);
      98       50302 :   Double_t ux2=fSqrtKx3*TMath::TanH(fKx2*xi2);
      99             :   
     100       50302 :   Double_t uy1=fSqrtKy3*TMath::TanH(fKy2*yi1);
     101       50302 :   Double_t uy2=fSqrtKy3*TMath::TanH(fKy2*yi2);
     102             :   
     103             :   
     104      150906 :   return Float_t(4.*fKx4*(TMath::ATan(ux2)-TMath::ATan(ux1))*
     105      100604 :                  fKy4*(TMath::ATan(uy2)-TMath::ATan(uy1)));
     106             : }
     107             : 
     108             : //______________________________________________________________________________
     109             : void 
     110             : AliMUONMathieson::SetPitch(Float_t p1)
     111             : {
     112             : /// Defines the pitch, and store its inverse, which is what is used in fact.
     113             : 
     114         292 :   fPitch = p1;
     115         146 :   if ( fPitch )
     116             :   {
     117         146 :     fInversePitch = 1/fPitch;
     118         146 :   }
     119             :   else
     120             :   {
     121           0 :     AliError(Form("Invalid pitch %e",p1));
     122           0 :     fInversePitch = 0.0;
     123             :   }
     124         146 : }
     125             :