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