EVE/Alieve/MUONChamberData.cxx

   1 #include "MUONChamberData.h"
   2
   3 #include <AliMUONSegmentation.h>
   4 #include <AliMUONConstants.h>
   5 #include <AliMUONGeometryTransformer.h>
   6 #include <AliMUONSegFactory.h>
   7 #include <mapping/AliMpDEIterator.h>
   8 #include <mapping/AliMpSectorSegmentation.h>
   9 #include <mapping/AliMpSector.h>
  10 #include <mapping/AliMpPad.h>
  11 #include <mapping/AliMpStationType.h>
  12 #include <mapping/AliMpDEManager.h>
  13 #include <mapping/AliMpSegmentation.h>
  14
  15 #include <TMath.h>
  16 #include <TVector2.h>
  17
  18 #include "Alieve/EventAlieve.h"
  19
  20 ///////////////////////////////////////////////////////////////////////////////
  21 ///
  22 /// MUONChamberData: geometry and digits
  23 ///
  24 ///////////////////////////////////////////////////////////////////////////////
  25
  26 using namespace Reve;
  27 using namespace Alieve;
  28
  29 ClassImp(MUONChamberData)
  30
  31 AliMUONSegmentation* MUONChamberData::fgSegmentation = 0;
  32 AliMUONGeometryTransformer* MUONChamberData::fgTransformer = 0;
  33
  34 //______________________________________________________________________
  35 MUONChamberData::MUONChamberData(Int_t chamber)
  36 {
  37   //
  38   // constructor
  39   //
  40
  41   Event *event = Alieve::gEvent;
  42
  43   TString dataPath = TString(event->GetTitle());
  44   dataPath.Append("/geometry.root");
  45
  46   fChamberID = chamber;
  47   fNDetElem  = 0;
  48   fNDigits   = 0;
  49   for (Int_t i = 0; i < 26; i++) {
  50     for (Int_t j = 0; j < 4; j++) {
  51       fFrameCoord[i][j] = 0.0;
  52     }
  53   }
  54   for (Int_t i = 0; i < 7*4096; i++) {
  55     fDigitBuffer[i] = 0.0;
  56   }
  57
  58   for (Int_t i = 0; i < 3; i++) {
  59     fChamberBox[i*2  ] = +9999;
  60     fChamberBox[i*2+1] = -9999;
  61   }
  62
  63   if (fgSegmentation == 0) {
  64     AliMUONSegFactory segFactory("volpath.dat","transform.dat");
  65     fgSegmentation = segFactory.CreateSegmentation();
  66     fgTransformer = new AliMUONGeometryTransformer(true);
  67     fgTransformer->ReadGeometryData("volpath.dat",dataPath.Data());
  68   }
  69
  70   Init(chamber);
  71
  72 }
  73
  74 //______________________________________________________________________
  75 MUONChamberData::~MUONChamberData()
  76 {
  77   //
  78   // destructor
  79   //
  80
  81 }
  82
  83 //______________________________________________________________________
  84 void MUONChamberData::DropData()
  85 {
  86   //
  87   // release the chamber data
  88   //
  89
  90   return;
  91
  92 }
  93
  94 //______________________________________________________________________
  95 void MUONChamberData::Init(Int_t chamber)
  96 {
  97   //
  98   // initialize the drawing coordinates of the chamber
  99   //
 100
 101   Float_t locP[3], gloP[3], locD[3], gloD[3];
 102   Float_t deltax, deltay;
 103   AliMpDEIterator it;
 104   const AliMpVSegmentation *vseg;
 105   const AliMpSectorSegmentation *sseg;
 106   const AliMpSector *sector;
 107   TVector2 position;
 108   TVector2 dimension;
 109
 110   for ( it.First(chamber); ! it.IsDone(); it.Next() ) {
 111
 112     Int_t detElemId = it.CurrentDEId();
 113
 114     if (chamber < 4) {
 115
 116       sseg = (AliMpSectorSegmentation*)
 117              AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0);
 118       sector = sseg->GetSector();
 119
 120       position  = sector->Position();
 121       dimension = sector->Dimensions(); // half length
 122
 123       locP[0] =  position.Px();
 124       locP[1] =  position.Py();
 125       locD[0] =  dimension.Px() * 2.;
 126       locD[1] =  dimension.Py() * 2.;
 127
 128       locP[2] = 0.0;
 129       locD[2] = 0.0;
 130
 131       fgTransformer->Local2Global(detElemId,
 132                                   locP[0], locP[1], locP[2],
 133                                   gloP[0], gloP[1], gloP[2]);
 134
 135       fgTransformer->Local2Global(detElemId,
 136                                   locD[0], locD[1], locD[2],
 137                                   gloD[0], gloD[1], gloD[2]);
 138
 139       fFrameCoord[fNDetElem][0] = gloP[0];
 140       fFrameCoord[fNDetElem][1] = gloP[1];
 141       fFrameCoord[fNDetElem][2] = gloD[0];
 142       fFrameCoord[fNDetElem][3] = gloD[1];
 143       fFrameCoord[fNDetElem][4] = gloP[2]; // Z position
 144
 145       fChamberBox[0] = TMath::Min(fChamberBox[0],gloP[0]-gloD[0]);
 146       fChamberBox[1] = TMath::Max(fChamberBox[1],gloP[0]+gloD[0]);
 147       fChamberBox[2] = TMath::Min(fChamberBox[2],gloP[1]-gloD[1]);
 148       fChamberBox[3] = TMath::Max(fChamberBox[3],gloP[1]+gloD[1]);
 149       fChamberBox[4] = TMath::Min(fChamberBox[4],gloP[2]);
 150       fChamberBox[5] = TMath::Max(fChamberBox[5],gloP[2]);
 151
 152     } else {
 153
 154       //AliMpStationType stationType = AliMpDEManager::GetStationType(detElemId);
 155
 156       if (!fgSegmentation->HasDE(detElemId)) {
 157         printf("Segmentation has no %d detElemId! \n",detElemId);
 158         continue;
 159       }
 160
 161       vseg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0);
 162
 163       if (vseg == 0) {
 164         printf("No MpVSegmentation for %d detElemId! \n",detElemId);
 165         continue;
 166       }
 167
 168       deltax = vseg->Dimensions().X();
 169       deltay = vseg->Dimensions().Y();
 170       locP[0] =  -deltax;
 171       locP[1] =  -deltay;
 172       locD[0] =  +deltax;
 173       locD[1] =  +deltay;
 174
 175       locP[2] = 0.0;
 176       locD[2] = 0.0;
 177
 178       fgTransformer->Local2Global(detElemId,
 179                                   locP[0], locP[1], locP[2],
 180                                   gloP[0], gloP[1], gloP[2]);
 181
 182       fgTransformer->Local2Global(detElemId,
 183                                   locD[0], locD[1], locD[2],
 184                                   gloD[0], gloD[1], gloD[2]);
 185
 186       fFrameCoord[fNDetElem][0] = gloP[0];
 187       fFrameCoord[fNDetElem][1] = gloP[1];
 188       fFrameCoord[fNDetElem][2] = gloD[0];
 189       fFrameCoord[fNDetElem][3] = gloD[1];
 190       fFrameCoord[fNDetElem][4] = gloP[2]; // Z position
 191
 192       fChamberBox[0] = TMath::Min(fChamberBox[0],gloP[0]);
 193       fChamberBox[0] = TMath::Min(fChamberBox[0],gloD[0]);
 194       fChamberBox[1] = TMath::Max(fChamberBox[1],gloP[0]);
 195       fChamberBox[1] = TMath::Max(fChamberBox[1],gloD[0]);
 196       fChamberBox[2] = TMath::Min(fChamberBox[0],gloP[1]);
 197       fChamberBox[2] = TMath::Min(fChamberBox[0],gloD[1]);
 198       fChamberBox[3] = TMath::Max(fChamberBox[1],gloP[1]);
 199       fChamberBox[3] = TMath::Max(fChamberBox[1],gloD[1]);
 200       fChamberBox[4] = TMath::Min(fChamberBox[4],gloP[2]);
 201       fChamberBox[5] = TMath::Max(fChamberBox[5],gloP[2]);
 202
 203     }
 204
 205     fNDetElem++;
 206
 207   }  // end detElemId loop
 208
 209   //printf("ChamberBox %d \n",chamber);
 210   //printf("%f %f \n",fChamberBox[0],fChamberBox[1]);
 211   //printf("%f %f \n",fChamberBox[2],fChamberBox[3]);
 212   //printf("%f %f \n",fChamberBox[4],fChamberBox[5]);
 213
 214 }
 215
 216 //______________________________________________________________________
 217 void MUONChamberData::RegisterDigit(Int_t detElemId, Int_t cathode, Int_t ix, Int_t iy, Int_t charge)
 218 {
 219   //
 220   // add a digit to this chamber
 221   //
 222
 223   Float_t locP[3], gloP[3], locD[3], gloD[3];
 224
 225   const AliMpVSegmentation* vseg = AliMpSegmentation::Instance()
 226     ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
 227
 228   AliMpPad pad = vseg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
 229
 230   locP[0] = pad.Position().X();
 231   locP[1] = pad.Position().Y();
 232   locD[0] = pad.Dimensions().X();
 233   locD[1] = pad.Dimensions().Y();
 234
 235   locP[2] = 0.0;
 236   locD[2] = 0.0;
 237
 238   fgTransformer->Local2Global(detElemId,
 239                               locP[0], locP[1], locP[2],
 240                               gloP[0], gloP[1], gloP[2]);
 241
 242   gloD[0] = locD[0];
 243   gloD[1] = locD[1];
 244   gloD[2] = gloP[2];
 245
 246   //printf("DigitP %f %f %f \n",gloP[0],gloP[1],gloP[2]);
 247   //printf("DigitD %f %f \n",gloD[0],gloD[1]);
 248
 249   if (cathode == 0) gloP[2] += 0.1;
 250   if (cathode == 1) gloP[2] -= 0.1;
 251
 252   fDigitBuffer[fNDigits  ] = gloP[0];
 253   fDigitBuffer[fNDigits+1] = gloP[1];
 254   fDigitBuffer[fNDigits+2] = gloD[0];
 255   fDigitBuffer[fNDigits+3] = gloD[1];
 256   fDigitBuffer[fNDigits+4] = gloP[2];
 257   fDigitBuffer[fNDigits+5] = charge;
 258   fDigitBuffer[fNDigits+6] = cathode;
 259
 260   fNDigits += 7;
 261
 262 }