EVE/Alieve/AliEveMUONChamberData.cxx

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