MUON/AliMUONClusterReconstructor.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 /* $Id$ */
  17
  18 ////////////////////////////////////
  19 //
  20 // MUON cluster reconstructor for MUON
  21 //
  22 // Should implement a virtual class ClusterFinder to chose between VS and AZ method
  23 ////////////////////////////////////
  24
  25 #include "AliMUONClusterReconstructor.h"
  26 #include "AliRun.h" // for gAlice
  27 #include "AliRunLoader.h"
  28 #include "AliLoader.h"
  29
  30 #include "AliMUON.h"
  31 #include "AliMUONDigit.h"
  32 #include "AliMUONConstants.h"
  33 #include "AliMUONData.h"
  34 #include "AliMUONClusterFinderVS.h"
  35 #include "AliMUONClusterInput.h"
  36 #include "AliMUONRawCluster.h"
  37 #include "AliRawReader.h" // for raw data
  38 #include "AliLog.h"
  39
  40
  41 const Int_t AliMUONClusterReconstructor::fgkDefaultPrintLevel = 0;
  42
  43 ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
  44
  45 //__________________________________________________________________________
  46 AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
  47   : TObject(),
  48     fMUONData(0),
  49     fPrintLevel(fgkDefaultPrintLevel),
  50     fDebug(0)
  51 {
  52   // Standard Constructor
  53
  54   // initialize loader's
  55   fLoader = loader;
  56
  57   // initialize container
  58   fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
  59
  60   // reconstruction model
  61   fRecModel = new AliMUONClusterFinderVS();
  62   //fRecModel = new AliMUONClusterFinderAZ();
  63
  64 }
  65
  66 //__________________________________________________________________________
  67 AliMUONClusterReconstructor::AliMUONClusterReconstructor()
  68   : TObject(),
  69     fMUONData(0),
  70     fPrintLevel(fgkDefaultPrintLevel),
  71     fDebug(0),
  72     fLoader(0)
  73 {
  74   // Default Constructor
  75 }
  76
  77 //_______________________________________________________________________
  78 AliMUONClusterReconstructor::AliMUONClusterReconstructor (const AliMUONClusterReconstructor& rhs)
  79   : TObject(rhs)
  80 {
  81 // Protected copy constructor
  82
  83   AliFatal("Not implemented.");
  84 }
  85
  86 //_______________________________________________________________________
  87 AliMUONClusterReconstructor &
  88 AliMUONClusterReconstructor::operator=(const AliMUONClusterReconstructor& rhs)
  89 {
  90 // Protected assignement operator
  91
  92   if (this == &rhs) return *this;
  93
  94   AliFatal("Not implemented.");
  95
  96   return *this;
  97 }
  98
  99 //__________________________________________________________________________
 100 AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
 101 {
 102
 103   if (fMUONData)
 104     delete fMUONData;
 105
 106   return;
 107 }
 108 //____________________________________________________________________
 109 void AliMUONClusterReconstructor::Digits2Clusters()
 110 {
 111 //
 112 //  Perform cluster finding
 113 //
 114
 115     AliMUON* pMUON = (AliMUON*) gAlice->GetModule("MUON");
 116     if (pMUON->WhichSegmentation() == 1)
 117       Digits2ClustersOld();
 118     else
 119       Digits2ClustersNew();
 120
 121 }
 122 //____________________________________________________________________
 123 void AliMUONClusterReconstructor::Digits2ClustersOld()
 124 {
 125
 126 //
 127 //  Perform cluster finding
 128 //
 129     TClonesArray *dig1, *dig2;
 130     Int_t ndig, k;
 131     dig1 = new TClonesArray("AliMUONDigit",1000);
 132     dig2 = new TClonesArray("AliMUONDigit",1000);
 133     AliMUONDigit *digit;
 134
 135 // Loop on chambers and on cathode planes
 136     TClonesArray * muonDigits;
 137
 138     for (Int_t ich = 0; ich < 10; ich++) {
 139
 140         fMUONData->ResetDigits();
 141         fMUONData->GetCathode(0);
 142         //TClonesArray *
 143         muonDigits = fMUONData->Digits(ich);
 144         ndig=muonDigits->GetEntriesFast();
 145         AliDebug(1,Form("1 Found %d digits in %p chamber %d", ndig, (void*)muonDigits,ich));
 146         TClonesArray &lhits1 = *dig1;
 147         Int_t n = 0;
 148         for (k = 0; k < ndig; k++) {
 149             digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
 150             new(lhits1[n++]) AliMUONDigit(*digit);
 151         }
 152         fMUONData->ResetDigits();
 153         fMUONData->GetCathode(1);
 154         muonDigits =  fMUONData->Digits(ich);
 155         ndig=muonDigits->GetEntriesFast();
 156         AliDebug(1,Form("2 Found %d digits in %p %d", ndig, (void*)muonDigits, ich));
 157         TClonesArray &lhits2 = *dig2;
 158         n=0;
 159
 160         for (k=0; k<ndig; k++) {
 161             digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
 162             new(lhits2[n++]) AliMUONDigit(*digit);
 163         }
 164
 165         if (fRecModel) {
 166             AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
 167             fRecModel->FindRawClusters();
 168         }
 169         // copy into the container
 170         TClonesArray* tmp = fRecModel->GetRawClusters();
 171         for (Int_t id = 0; id < tmp->GetEntriesFast(); id++) {
 172           AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
 173           fMUONData->AddRawCluster(ich, *pClus);
 174         }
 175         dig1->Delete();
 176         dig2->Delete();
 177     } // for ich
 178     delete dig1;
 179     delete dig2;
 180 }
 181 //____________________________________________________________________
 182 void AliMUONClusterReconstructor::Digits2ClustersNew()
 183 {
 184
 185     TClonesArray *dig1, *dig2, *digAll;
 186     Int_t ndig, k, idDE, idDE_prev;
 187     dig1 = new TClonesArray("AliMUONDigit",1000);
 188     dig2 = new TClonesArray("AliMUONDigit",1000);
 189     digAll = new TClonesArray("AliMUONDigit",2000);
 190
 191     AliMUONDigit* digit;
 192
 193     TArrayI id(200); // contains the different IdDE
 194
 195
 196 // Loop on chambers and on cathode planes
 197     TClonesArray* muonDigits;
 198     Int_t n2;
 199     Int_t n1;
 200     Int_t flag = 0;
 201
 202     for (Int_t ich = 0; ich < AliMUONConstants::NTrackingCh(); ich++) {
 203
 204       id.Reset();
 205       n1 = 0;
 206       n2 = 0;
 207       //cathode 0
 208       fMUONData->ResetDigits();
 209       fMUONData->GetCathode(0);
 210       muonDigits = fMUONData->Digits(ich);
 211       ndig = muonDigits->GetEntriesFast();
 212       TClonesArray &lDigit = *digAll;
 213
 214       idDE_prev = 0;
 215
 216       for (k = 0; k < ndig; k++) {
 217
 218         digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
 219         new(lDigit[n1++]) AliMUONDigit(*digit);
 220         idDE = digit->DetElemId();
 221         if (idDE != idDE_prev) {
 222           id.AddAt(idDE,n2++);
 223         }
 224         idDE_prev = idDE;
 225       }
 226
 227       //cathode 1
 228       fMUONData->ResetDigits();
 229       fMUONData->GetCathode(1);
 230       muonDigits =  fMUONData->Digits(ich);
 231       ndig = muonDigits->GetEntriesFast();
 232
 233       Int_t idSize = n2;
 234
 235       for (k = 0; k < ndig; k++) {
 236
 237         digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
 238         new(lDigit[n1++]) AliMUONDigit(*digit);
 239         idDE = digit->DetElemId();
 240         flag = 0;
 241
 242         // looking for new idDE in cathode 1 (method to be checked CF)
 243         for (Int_t n = 0; n < idSize; n++) {
 244           if (idDE == id[n]) {
 245             flag = 1;
 246             break;
 247           }
 248         }
 249         if (flag) continue;
 250         id.AddAt(idDE,n2++);
 251       }
 252
 253       idSize = n2;
 254
 255       // loop over id DE
 256       for (idDE = 0; idDE < idSize; idDE++) {
 257         TClonesArray &lhits1 = *dig1;
 258         TClonesArray &lhits2 = *dig2;
 259         n1 = n2 = 0;
 260         //      printf("idDE %d\n", id[idDE]);
 261
 262         for (k = 0; k < digAll->GetEntriesFast(); k++) {
 263           digit = (AliMUONDigit*) digAll->UncheckedAt(k);
 264           //      printf("digit idDE %d\n", digit->DetElemId());
 265           if (id[idDE] == digit->DetElemId()) {
 266             if (digit->Cathode() == 1)
 267               new(lhits1[n1++]) AliMUONDigit(*digit);
 268             else
 269               new(lhits2[n2++]) AliMUONDigit(*digit);
 270           }
 271         }
 272
 273         // cluster finder
 274         if (fRecModel) {
 275           AliMUONClusterInput::Instance()->SetDigits(ich, id[idDE], dig1, dig2);
 276           fRecModel->FindRawClusters();
 277         }
 278         // copy into the container
 279         TClonesArray* tmp = fRecModel->GetRawClusters();
 280         for (Int_t id = 0; id < tmp->GetEntriesFast(); id++) {
 281           AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
 282           fMUONData->AddRawCluster(ich, *pClus);
 283         }
 284         dig1->Delete();
 285         dig2->Delete();
 286
 287       } // idDE
 288       digAll->Delete();
 289     } // for ich
 290     delete dig1;
 291     delete dig2;
 292     delete digAll;
 293 }
 294
 295 //____________________________________________________________________
 296 void AliMUONClusterReconstructor::Digits2Clusters(AliRawReader* /*rawReader*/)
 297 {
 298
 299 //  Perform cluster finding form raw data
 300
 301    AliFatal("clusterization not implemented for raw data input");
 302 }
 303 //_______________________________________________________________________
 304 void AliMUONClusterReconstructor::Trigger2Trigger()
 305 {
 306 // copy trigger from TreeD to TreeR
 307
 308   fMUONData->SetTreeAddress("GLT");
 309   fMUONData->GetTriggerD();
 310 }
 311 //_______________________________________________________________________
 312 void AliMUONClusterReconstructor::Trigger2Trigger(AliRawReader* /*rawReader*/)
 313 {
 314 // call the Trigger Algorithm from raw data and fill TreeR
 315
 316    AliFatal("Trigger not implemented for raw data input");
 317
 318 }