EVE/Alieve/MUONChamberData.cxx

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