MUON/AliMUONSegmentationV04.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.7  2000/12/21 22:12:41  morsch
  19 Clean-up of coding rule violations,
  20
  21 Revision 1.6  2000/10/18 11:42:06  morsch
  22 - AliMUONRawCluster contains z-position.
  23 - Some clean-up of useless print statements during initialisations.
  24
  25 Revision 1.5  2000/10/04 18:50:05  morsch
  26 In Init(): (*fDpxD)[fNsec-1]=fDpx;
  27
  28 Revision 1.4  2000/10/03 21:48:07  morsch
  29 Adopt to const declaration of some of the methods in AliSegmentation.
  30
  31 Revision 1.3  2000/06/29 12:34:09  morsch
  32 AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
  33 it usable with any other geometry class. The link to the object to which it belongs is
  34 established via an index. This assumes that there exists a global geometry manager
  35 from which the pointer to the parent object can be obtained (in our case gAlice).
  36
  37 Revision 1.2  2000/06/15 07:58:48  morsch
  38 Code from MUON-dev joined
  39
  40 Revision 1.1.2.1  2000/06/09 21:38:15  morsch
  41 AliMUONSegmentationV04 code  from  AliMUONSegResV04.cxx
  42
  43 */
  44
  45 /////////////////////////////////////////////////////
  46 //  Segmentation and Response classes version 04   //
  47 /////////////////////////////////////////////////////
  48
  49
  50 #include "AliMUONSegmentationV04.h"
  51 #include "AliMUONChamber.h"
  52 #include "AliMUON.h"
  53 #include "AliRun.h"
  54
  55 #include <TMath.h>
  56
  57 //___________________________________________
  58 ClassImp(AliMUONSegmentationV04)
  59
  60
  61 void AliMUONSegmentationV04::Init(Int_t chamber)
  62 {
  63
  64 //
  65 //  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
  66 //  These arrays help in converting from real to pad co-ordinates and
  67 //  vice versa
  68 //
  69 //  Segmentation is defined by rectangular modules approximating
  70 //  concentric circles as shown below
  71 //
  72 //  PCB module size in cm
  73   //printf("\n Initialise Segmentation V04 \n");
  74
  75     const Float_t kDxPCB=40, kDyPCB=40;
  76 //  PCB distribution (7 rows with 1+3 segmentation regions)
  77     const Int_t kpcb[7][4] = {{1, 2, 2, 2},
  78                               {0, 3, 2, 2},
  79                               {0, 2, 2, 2},
  80                               {0, 0, 3, 3},
  81                               {0, 0, 2, 3},
  82                               {0, 0, 0, 4},
  83                               {0, 0, 0, 3}};
  84
  85
  86 //
  87 //                             3 3 3 | 3 3 3
  88 //                           3 3 3 3 | 3 3 3 3
  89 //                         3 3 3 2 2 | 2 2 3 3 3
  90 //                       3 3 3 2 2 2 | 2 2 2 3 3 3
  91 //                       3 3 2 2 1 1 | 1 1 2 2 3 3
  92 //                     3 3 2 2 1 1 1 | 1 1 1 2 2 3 3
  93 //                     3 3 2 2 1 1 0 | 0 1 1 2 2 3 3
  94 //                    ------------------------------
  95 //                     3 3 2 2 1 1 0 | 0 1 1 2 2 3 3
  96 //                     3 3 2 2 1 1 1 | 1 1 1 2 2 3 3
  97 //                       3 3 2 2 1 1 | 1 1 2 2 3 3
  98 //                       3 3 3 2 2 2 | 2 2 2 3 3 3
  99 //                         3 3 3 2 2 | 2 2 3 3 3
 100 //                           3 3 3 3 | 3 3 3 3
 101 //                             3 3 3 | 3 3 3
 102 //
 103 // number of pad rows per PCB
 104 //
 105     Int_t nPyPCB=Int_t(kDyPCB/fDpy);
 106 //
 107 // maximum number of pad rows
 108     fNpy=7*nPyPCB;
 109 //
 110 //  Calculate padsize along x
 111     (*fDpxD)[fNsec-1]=fDpx;
 112     if (fNsec > 1) {
 113         for (Int_t i=fNsec-2; i>=0; i--){
 114             (*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
 115         }
 116     }
 117 //
 118 // fill the arrays defining the pad segmentation boundaries
 119 //
 120 //  loop over pcb module rows
 121     Int_t iy=0;
 122     for (Int_t irow=0; irow<7; irow++) {
 123 //
 124 //  loop over pads along the anode wires
 125         for (Int_t i=0; i<=nPyPCB; i++) {
 126 //  iy counts the padrow
 127             iy++;
 128 //  Loop over sectors (isec=0 is the dead space surounding the beam pipe)
 129             for (Int_t isec=0; isec<4; isec++) {
 130                 if (isec==0) {
 131                     fNpxS[0][iy]=kpcb[irow][0]*Int_t(kDxPCB/(*fDpxD)[0]);
 132                     fCx[0][iy]=kpcb[irow][0]*kDxPCB;
 133                 } else {
 134                     fNpxS[isec][iy]=fNpxS[isec-1][iy]
 135                         +kpcb[irow][isec]*Int_t(kDxPCB/(*fDpxD)[isec]);
 136
 137                     fCx[isec][iy]=fCx[isec-1][iy]
 138                     +kpcb[irow][isec]*kDxPCB;
 139                 }
 140             } // sectors
 141         } // pad raws in module
 142     } // PCB rows
 143
 144     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
 145     fChamber=&(pMUON->Chamber(chamber));
 146     fZ = fChamber->Z();
 147 }
 148
 149 void AliMUONSegmentationV04::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) const
 150 {
 151 // Returns test point on the pad plane.
 152 // Used during determination of the segmoid correction of the COG-method
 153     n=3;
 154     x[0]=(fCx[1][1]+fCx[0][1])/2/TMath::Sqrt(2.);
 155     y[0]=x[0];
 156     x[1]=(fCx[2][1]+fCx[1][1])/2/TMath::Sqrt(2.);
 157     y[1]=x[1];
 158     x[2]=(fCx[3][1]+fCx[2][1])/2/TMath::Sqrt(2.);
 159     y[2]=x[2];
 160 }
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176