AliRoot Core  ee782a0 (ee782a0)
MUONClusterInfo.C
Go to the documentation of this file.
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 
23 
24 #if !defined(__CINT__) || defined(__MAKECINT__)
25 #include <TStopwatch.h>
26 #include <TFile.h>
27 #include <TObjArray.h>
28 #include <TTree.h>
29 #include <TString.h>
30 #include <Riostream.h>
31 #include <TRandom.h>
32 #include <TROOT.h>
33 #include <TMath.h>
34 
35 // STEER includes
36 #include "AliESDEvent.h"
37 #include "AliRecoParam.h"
38 #include "AliCDBManager.h"
39 #include "AliRunLoader.h"
40 #include "AliLoader.h"
41 #include "AliHeader.h"
42 
43 // MUON includes
44 #include "AliMpConstants.h"
45 #include "AliMpSegmentation.h"
46 #include "AliMpVSegmentation.h"
47 #include "AliMpPad.h"
48 #include "AliMUONCDB.h"
49 #include "AliMUONCalibrationData.h"
50 #include "AliMUONVCalibParam.h"
51 #include "AliMUONPadInfo.h"
52 #include "AliMUONClusterInfo.h"
53 #include "AliMUONRecoParam.h"
54 #include "AliMUONESDInterface.h"
55 #include "AliMUONVDigit.h"
56 #include "AliMUONVDigitStore.h"
57 #include "AliMUONVCluster.h"
58 #include "AliMUONVClusterStore.h"
59 #include "AliMUONTrack.h"
60 #include "AliMUONTrackParam.h"
61 #endif
62 
63 const Int_t printLevel = 1;
64 
65 TTree* GetESDTree(TFile *esdFile);
67 
68 //-----------------------------------------------------------------------
69 void MUONClusterInfo(Int_t nevents = -1, const char* esdFileName = "AliESDs.root", const char* inFileName = "galice.root",
70  const TString ocdbPath = "local://$ALICE_ROOT/OCDB", const char* outFileName = "clusterInfo.root")
71 {
83 
84  Bool_t useESD = (strcmp(esdFileName,""));
85  Bool_t useRecPoints = (strcmp(inFileName,""));
86  if (!useESD && !useRecPoints) {
87  Error("MUONClusterInfo","you must provide ESD and/or galice root file(s)");
88  return;
89  }
90 
91  AliMUONClusterInfo* clusterInfo = new AliMUONClusterInfo();
92  AliMUONPadInfo padInfo;
94  AliMUONESDInterface esdInterface;
95  AliMUONVClusterStore* clusterStore = 0x0;
96  AliMUONVDigitStore* digitStore = 0x0;
97 
98  // open the ESD file and tree and connect the ESD event
99  TFile* esdFile = 0x0;
100  TTree* esdTree = 0x0;
101  AliESDEvent* esd = 0x0;
102  Int_t runNumber = -1;
103  if (useESD) {
104  esdFile = TFile::Open(esdFileName);
105  esdTree = GetESDTree(esdFile);
106  esd = new AliESDEvent();
107  esd->ReadFromTree(esdTree);
108  if (esdTree->GetEvent(0) <= 0) {
109  Error("MUONClusterInfo", "no ESD object found for event 0");
110  return;
111  }
112  runNumber = esd->GetRunNumber();
113  }
114 
115  // get the cluster from RecPoints
116  AliRunLoader * rl = 0x0;
117  AliLoader* MUONLoader = 0x0;
118  if (useRecPoints) {
119  rl = AliRunLoader::Open(inFileName,"MUONLoader");
120  MUONLoader = rl->GetDetectorLoader("MUON");
121  MUONLoader->LoadRecPoints("READ");
122  MUONLoader->LoadDigits("READ");
123  rl->LoadHeader();
124  if (runNumber < 0) runNumber = rl->GetHeader()->GetRun();
125  }
126 
127  // load necessary data from OCDB
129  AliCDBManager::Instance()->SetRun(runNumber);
130  if (!AliMUONCDB::LoadField()) return;
131  if (!AliMUONCDB::LoadMapping(kTRUE)) return;
133  if (!recoParam) return;
134 
135  // reset tracker for track restoring initial track parameters at cluster
137 
138  // prepare access to calibration data
139  calibData = new AliMUONCalibrationData(runNumber);
140 
141  // prepare the output tree
142  gROOT->cd();
143  TFile* clusterInfoFile = TFile::Open(outFileName, "RECREATE");
144  clusterInfoFile->SetCompressionLevel(1);
145 
146  TTree* clusterInfoTree = new TTree("clusterInfoTree","clusterInfoTree");
147  clusterInfoTree->Branch("clusterInfo", &clusterInfo, 32000, 99);
148 
149  // timer start...
150  TStopwatch timer;
151 
152  // Loop over events
153  if (useESD) {
154  if (nevents > 0) nevents = TMath::Min(nevents,(Int_t)esdTree->GetEntries());
155  else nevents = (Int_t)esdTree->GetEntries();
156  } else {
157  if (nevents > 0) nevents = TMath::Min(nevents,(Int_t)rl->GetNumberOfEvents());
158  else nevents = (Int_t)rl->GetNumberOfEvents();
159  }
160  for (Int_t iEvent = 0; iEvent < nevents; iEvent++) {
161 
162  //----------------------------------------------//
163  // -------------- process event --------------- //
164  //----------------------------------------------//
165  // get the ESD of current event
166  if (useESD) {
167  esdTree->GetEvent(iEvent);
168  if (!esd) {
169  Error("MUONClusterInfo", "no ESD object found for event %d", iEvent);
170  return;
171  }
172  // load the current esd event
173  esdInterface.LoadEvent(*esd);
174  // get digit store
175  if (!useRecPoints) digitStore = esdInterface.GetDigits();
176  }
177 
178  if (useRecPoints) {
179  if (!(rl->GetEvent(iEvent) == 0)) {
180  Error("MUONClusterInfo", "unable to load event %d", iEvent);
181  return;
182  }
183  // get the clusters of current event
184  TTree* treeR = MUONLoader->TreeR();
185  clusterStore = AliMUONVClusterStore::Create(*treeR);
186  if ( clusterStore != 0x0 ) {
187  clusterStore->Clear();
188  clusterStore->Connect(*treeR);
189  treeR->GetEvent(0);
190  }
191  // get the digits of current event
192  TTree* treeD = MUONLoader->TreeD();
193  if (treeD) {
194  digitStore = AliMUONVDigitStore::Create(*treeD);
195  if ( digitStore != 0x0 ) {
196  digitStore->Clear();
197  digitStore->Connect(*treeD);
198  treeD->GetEvent(0);
199  }
200  }
201  }
202 
203  //----------------------------------------------//
204  // ------------- fill cluster info ------------ //
205  //----------------------------------------------//
206  // --- loop over the refitted tracks ---
207  if (useESD) {
208 
209  TIter nextTrack(esdInterface.CreateTrackIterator());
211  while ((track = static_cast<AliMUONTrack*>(nextTrack()))) {
212 
213  UInt_t muonClusterMap = buildClusterMap(*track);
214 
215  // loop over clusters
216  AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->First());
217  while (trackParam) {
218  clusterInfo->Clear("C");
219 
220  // fill cluster info
221  AliMUONVCluster* cluster = trackParam->GetClusterPtr();
222  clusterInfo->SetRunId(esd->GetRunNumber());
223  clusterInfo->SetEventId(iEvent);
224  clusterInfo->SetZ(cluster->GetZ());
225  clusterInfo->SetClusterId(cluster->GetUniqueID());
226  clusterInfo->SetClusterXY(cluster->GetX(), cluster->GetY());
227  clusterInfo->SetClusterXYErr(cluster->GetErrX(), cluster->GetErrY());
228  clusterInfo->SetClusterChi2(cluster->GetChi2());
229  clusterInfo->SetClusterCharge(cluster->GetCharge());
230 
231  // fill track info
232  clusterInfo->SetTrackId(track->GetUniqueID());
233  clusterInfo->SetTrackXY(trackParam->GetNonBendingCoor(), trackParam->GetBendingCoor());
234  clusterInfo->SetTrackThetaXY(TMath::ATan(trackParam->GetNonBendingSlope()), TMath::ATan(trackParam->GetBendingSlope()));
235  clusterInfo->SetTrackP(trackParam->P());
236  const TMatrixD paramCov = trackParam->GetCovariances();
237  clusterInfo->SetTrackXYErr(TMath::Sqrt(paramCov(0,0)), TMath::Sqrt(paramCov(2,2)));
238  clusterInfo->SetTrackChi2(track->GetNormalizedChi2());
239  clusterInfo->SetTrackCharge((Short_t)trackParam->GetCharge());
240  clusterInfo->SetTrackNHits(track->GetNClusters());
241  clusterInfo->SetTrackChamberHitMap(muonClusterMap);
242 
243  // fill pad info if available
244  if (digitStore) for (Int_t i=0; i<cluster->GetNDigits(); i++) {
245  AliMUONVDigit* digit = digitStore->FindObject(cluster->GetDigitId(i));
246  if (!digit) continue;
247 
248  // pad location
250  GetMpSegmentation(digit->DetElemId(),AliMp::GetCathodType(digit->Cathode()));
251  AliMpPad pad = seg->PadByIndices(digit->PadX(), digit->PadY());
252 
253  // calibration parameters
254  AliMUONVCalibParam* ped = calibData->Pedestals(digit->DetElemId(), digit->ManuId());
255  Int_t manuChannel = digit->ManuChannel();
256  Int_t planeType = 0;
258  planeType = 1;
259  }
260 
261  // fill pad info
262  padInfo.SetPadId(digit->GetUniqueID());
263  padInfo.SetPadPlaneType(planeType);
264  padInfo.SetPadXY(pad.GetPositionX(), pad.GetPositionY());
265  padInfo.SetPadDimXY(pad.GetDimensionX(), pad.GetDimensionY());
266  padInfo.SetPadCharge((Double_t)digit->Charge());
267  padInfo.SetPadADC(digit->ADC());
268  padInfo.SetSaturated(digit->IsSaturated());
269  padInfo.SetCalibrated(digit->IsCalibrated());
270  padInfo.SetPedestal(ped->ValueAsFloatFast(manuChannel,0), ped->ValueAsFloatFast(manuChannel,1));
271 
272  clusterInfo->AddPad(padInfo);
273  }
274 
275  // remove clusters attached to a track
276  if (useRecPoints) {
277  AliMUONVCluster* cl = clusterStore->FindObject(cluster->GetUniqueID());
278  if (cl) clusterStore->Remove(*cl);
279  }
280 
281  // fill cluster info tree
282  clusterInfoTree->Fill();
283 
284  trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->After(trackParam));
285  }
286 
287  }
288 
289  }
290 
291  // --- loop over clusters not attached to a track ---
292  if (useRecPoints) {
293 
294  TIter nextCluster(clusterStore->CreateIterator());
295  AliMUONVCluster *cluster;
296  while ( ( cluster = static_cast<AliMUONVCluster*>(nextCluster()) ) ) {
297 
298  clusterInfo->Clear("C");
299 
300  // fill cluster info
301  clusterInfo->SetRunId(rl->GetRunNumber());
302  clusterInfo->SetEventId(iEvent);
303  clusterInfo->SetZ(cluster->GetZ());
304  clusterInfo->SetClusterId(cluster->GetUniqueID());
305  clusterInfo->SetClusterXY(cluster->GetX(), cluster->GetY());
306  clusterInfo->SetClusterXYErr(cluster->GetErrX(), cluster->GetErrY());
307  clusterInfo->SetClusterChi2(cluster->GetChi2());
308  clusterInfo->SetClusterCharge(cluster->GetCharge());
309 
310  // fill dummy track info
311  clusterInfo->SetTrackId(0);
312  clusterInfo->SetTrackXY(0.,0.);
313  clusterInfo->SetTrackThetaXY(0.,0.);
314  clusterInfo->SetTrackP(0.);
315  clusterInfo->SetTrackXYErr(0.,0.);
316  clusterInfo->SetTrackChi2(0.);
317  clusterInfo->SetTrackCharge(0);
318  clusterInfo->SetTrackNHits(0);
319  clusterInfo->SetTrackChamberHitMap(0);
320 
321  // fill pad info if available
322  if (digitStore) for (Int_t i=0; i<cluster->GetNDigits(); i++) {
323  AliMUONVDigit* digit = digitStore->FindObject(cluster->GetDigitId(i));
324  if (!digit) continue;
325 
326  // pad location
328  GetMpSegmentation(digit->DetElemId(),AliMp::GetCathodType(digit->Cathode()));
329  AliMpPad pad = seg->PadByIndices(digit->PadX(), digit->PadY());
330 
331  // calibration parameters
332  AliMUONVCalibParam* ped = calibData->Pedestals(digit->DetElemId(), digit->ManuId());
333  Int_t manuChannel = digit->ManuChannel();
334  Int_t planeType = 0;
336  planeType = 1;
337  }
338 
339  // fill pad info
340  padInfo.SetPadId(digit->GetUniqueID());
341  padInfo.SetPadPlaneType(planeType);
342  padInfo.SetPadXY(pad.GetPositionX(), pad.GetPositionY());
343  padInfo.SetPadDimXY(pad.GetDimensionX(), pad.GetDimensionY());
344  padInfo.SetPadCharge((Double_t)digit->Charge());
345  padInfo.SetPadADC(digit->ADC());
346  padInfo.SetSaturated(digit->IsSaturated());
347  padInfo.SetCalibrated(digit->IsCalibrated());
348  padInfo.SetPedestal(ped->ValueAsFloatFast(manuChannel,0), ped->ValueAsFloatFast(manuChannel,1));
349 
350  clusterInfo->AddPad(padInfo);
351  }
352 
353  // fill cluster info tree
354  clusterInfoTree->Fill();
355 
356  }
357 
358  delete digitStore;
359  delete clusterStore;
360 
361  }
362 
363  }
364 
365  // ...timer stop
366  timer.Stop();
367  printf("Writing Tree\n");
368  // write output tree
369  clusterInfoFile->cd();
370  clusterInfoTree->Write();
371  printf("Deleting Tree\n");
372  delete clusterInfoTree;
373  printf("Closing File\n");
374  clusterInfoFile->Close();
375 
376  // free memory
377  printf("Deleting calibData\n");
378  delete calibData;
379  printf("Deleting clusterInfo\n");
380  delete clusterInfo;
381  if (useRecPoints) {
382  MUONLoader->UnloadDigits();
383  MUONLoader->UnloadRecPoints();
384  rl->UnloadHeader();
385  delete rl;
386  }
387  if (useESD) {
388  esdFile->Close();
389  delete esd;
390  }
391  cout<<endl<<"time to fill cluster/track info: R:"<<timer.RealTime()<<" C:"<<timer.CpuTime()<<endl<<endl;
392 }
393 
394 //-----------------------------------------------------------------------
395 TTree* GetESDTree(TFile *esdFile)
396 {
399 
400  if (!esdFile || !esdFile->IsOpen()) {
401  Error("GetESDTree", "opening ESD file failed");
402  exit(-1);
403  }
404 
405  TTree* tree = (TTree*) esdFile->Get("esdTree");
406  if (!tree) {
407  Error("GetESDTree", "no ESD tree found");
408  exit(-1);
409  }
410 
411  return tree;
412 
413 }
414 
415 
416 //-----------------------------------------------------------------------
418 {
420 
421  UInt_t muonClusterMap = 0;
422 
423  AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>(track.GetTrackParamAtCluster()->First());
424  while (trackParam) {
425 
426  muonClusterMap |= BIT(trackParam->GetClusterPtr()->GetChamberId());
427 
428  trackParam = static_cast<AliMUONTrackParam*>(track.GetTrackParamAtCluster()->After(trackParam));
429  }
430 
431  return muonClusterMap;
432 
433 }
434 
virtual Int_t ManuChannel() const =0
The channel within ManuId() this digit belongs to (manuChannel for tracker, localBoardChannel for tri...
printf("Chi2/npoints = %f\n", TMath::Sqrt(chi2/npoints))
void SetCalibrated(Bool_t calibrated=kTRUE)
Set the pad as being calibrated or not.
TFile * Open(const char *filename, Long64_t &nevents)
void SetTrackNHits(UInt_t NHits)
Set the total number of hits associated to the track leaving this cluster.
void SetPedestal(Float_t mean, Float_t sigma)
Set pedestal parameters.
virtual Int_t PadY() const =0
The y-index of this digit (>=0)
void SetClusterXY(Double_t x, Double_t y)
Set cluster coordinates (cm)
void UnloadRecPoints() const
Definition: AliLoader.h:132
Interface for a digit container.
virtual Int_t GetRun() const
Definition: AliHeader.h:35
static AliMpSegmentation * Instance(Bool_t warn=true)
virtual Double_t GetZ() const =0
Return coordinate Z (cm)
void SetPadDimXY(Double_t dX, Double_t dY)
Set pad dimension (cm)
void SetPadCharge(Double_t charge)
Set the calibrated charge.
Double_t GetBendingCoor() const
return bending coordinate (cm)
TStopwatch timer
Definition: kNNSpeed.C:15
virtual Float_t ValueAsFloatFast(Int_t i, Int_t j=0) const =0
Same as above but without bound checking.
void LoadEvent(AliESDEvent &esdEvent, Bool_t refit=kTRUE)
static void ResetTracker(const AliMUONRecoParam *recoParam=0x0, Bool_t info=kTRUE)
Int_t GetRunNumber() const
Definition: AliRunLoader.h:101
virtual Int_t ADC() const =0
Raw ADC value of this digit.
void SetClusterCharge(Double_t charge)
Set the total cluster charge.
TROOT * gROOT
void SetClusterChi2(Double_t clusterChi2)
set cluster Chi2
TTree * TreeD() const
Definition: AliLoader.h:87
virtual Double_t GetErrX() const =0
Return resolution (cm) on coordinate X.
AliLoader * GetDetectorLoader(const char *detname)
TIterator * CreateTrackIterator() const
void SetPadPlaneType(Int_t planeType)
Set the plane type 0=Bending 1=NonBending.
Track parameters in ALICE dimuon spectrometer.
void SetPadADC(Int_t adc)
Set the raw charge.
void SetTrackChi2(Double_t trackChi2)
set track Chi2
virtual void Clear(Option_t *opt="")=0
Clear container.
Class with MUON reconstruction parameters.
AliTPCfastTrack * track
Int_t LoadRecPoints(Option_t *opt="")
Definition: AliLoader.h:113
Bool_t LoadMapping(Bool_t segmentationOnly)
Definition: AliMUONCDB.cxx:502
void SetZ(Double_t z)
Set cluster/track Z-position (cm)
virtual Float_t Charge() const =0
The charge of this digit, calibrated or not depending on IsCalibrated()
virtual Bool_t IsCalibrated() const =0
Whether this digit has been calibrated or not (see note 1 in AliMUONVDigit.cxx)
virtual AliMpPad PadByIndices(Int_t ix, Int_t iy, Bool_t warning=true) const =0
Find pad by indices.
virtual Int_t DetElemId() const =0
The detection element this digit belongs to.
Bool_t LoadField()
Definition: AliMUONCDB.cxx:478
static AliRunLoader * Open(const char *filename="galice.root", const char *eventfoldername=AliConfig::GetDefaultEventFolderName(), Option_t *option="READ")
TTree * TreeR() const
Definition: AliLoader.h:89
virtual UInt_t GetDigitId(Int_t i) const =0
Return Id of digits i.
Container of calibration values for a given number of channels.
Double_t GetBendingSlope() const
return bending slope (cm ** -1)
TTree * tree
abstract base class for clusters
void UnloadDigits() const
Definition: AliLoader.h:131
Double_t GetCharge() const
return the charge (assumed forward motion)
virtual AliMUONVDigitStore * Create() const =0
Create an (empty) object of the same concrete class as *this.
virtual AliMUONVStore * Create() const =0
Create an empty copy of this.
void SetClusterXYErr(Double_t xErr, Double_t yErr)
Set cluster resolution (cm)
AliHeader * GetHeader() const
virtual void Clear(Option_t *opt="")
Int_t GetRunNumber() const
Definition: AliESDEvent.h:141
virtual Int_t Cathode() const =0
Cathode number this digit is on (0 or 1)
void SetTrackThetaXY(Double_t thetaX, Double_t thetaY)
Set track angles (radian)
Converter between MUON track/cluster/digit and ESDMuon track/cluster/pad.
Double_t GetPositionY() const
Return the pad x position (in cm)
Definition: AliMpPad.h:81
const Int_t printLevel
virtual Double_t GetErrY() const =0
Return resolution (cm) on coordinate Y.
non-bending plane
void SetSaturated(Bool_t saturated=kTRUE)
Set the pad as being saturated or not.
void SetTrackP(Double_t p)
Set track momentum (MeV/c)
virtual Int_t GetNDigits() const =0
Return number of associated digits.
Interface of a cluster container.
void SetEventId(Int_t eventId)
set event number
Int_t LoadHeader()
virtual Double_t GetChi2() const =0
Return chi2 of cluster.
virtual AliMUONVCluster * FindObject(const TObject *object) const
Find an object.
Double_t P() const
AliMp::CathodType GetCathodType(Int_t cathodNumber)
Convert integer number in enum;.
Int_t GetNumberOfEvents()
virtual AliMUONVCluster * Remove(AliMUONVCluster &cluster)=0
Remove a cluster object to the store.
virtual Int_t PadX() const =0
The x-index of this digit (>=0)
void SetRun(Int_t run)
AliMUONVStore * Pedestals() const
Get the pedestal store.
void SetTrackId(UInt_t trackId)
set track ID
void SetTrackXY(Double_t x, Double_t y)
Set track coordinates (cm)
void SetDefaultStorage(const char *dbString)
AliMUONCalibrationData * calibData
static Int_t GetChamberId(UInt_t uniqueID)
Return chamber id (0..), part of the uniqueID.
Int_t GetEvent(Int_t evno)
virtual Double_t GetY() const =0
Return coordinate Y (cm)
TTree * GetESDTree(TFile *esdFile)
Single entry point to access MUON calibration data.
void SetTrackXYErr(Double_t xErr, Double_t yErr)
Set track resolution (cm)
void SetRunId(Int_t runId)
set run number
void ReadFromTree(TTree *tree, Option_t *opt="")
The abstract base class for the segmentation.
Double_t GetDimensionY() const
Return the y pad dimension - half length (in cm)
Definition: AliMpPad.h:86
UInt_t buildClusterMap(AliMUONTrack &track)
void SetPadId(UInt_t padId)
Set pad ID.
Double_t GetNonBendingCoor() const
return non bending coordinate (cm)
virtual Int_t ManuId() const =0
The electronic card id this digit belongs to (manuId for tracker, localboardId for trigger) ...
ABC of a MUON digit.
Definition: AliMUONVDigit.h:18
AliMUONVCluster * GetClusterPtr() const
get pointeur to associated cluster
static Int_t runNumber
Definition: pdc06_config.C:126
Class which encapsuate all information about a pad.
Definition: AliMpPad.h:22
virtual Bool_t IsSaturated() const =0
Whether the ADC has saturated.
virtual Double_t GetX() const =0
Return coordinate X (cm)
void SetTrackChamberHitMap(UInt_t trackChamberHitMap)
Set the map of hit chambers.
virtual void Clear(Option_t *opt="")=0
Clear ourselves (i.e. Reset)
Double_t GetPositionX() const
Return the pad x position (in cm)
Definition: AliMpPad.h:79
AliMUONVDigitStore * GetDigits() const
Return internal track store.
Reconstructed track in ALICE dimuon spectrometer.
Definition: AliMUONTrack.h:24
virtual AliMUONVDigit * FindObject(const TObject *object) const
Find an object (default is to forward to FindObject(object->GetUniqueID())
Int_t LoadDigits(Option_t *opt="")
Definition: AliLoader.h:106
static AliCDBManager * Instance(TMap *entryCache=NULL, Int_t run=-1)
Class to summarize ESD data at cluster.
virtual Double_t GetCharge() const =0
Set the cluster charge.
virtual TIterator * CreateIterator() const =0
Return an iterator to loop over the whole store.
Class to summarize ESD data at pad.
Double_t GetDimensionX() const
Return the x pad dimension - half length (in cm)
Definition: AliMpPad.h:84
virtual Bool_t Connect(TTree &tree, Bool_t alone=kTRUE) const
Connect us to a TTree (only valid if CanConnect()==kTRUE)
void AddPad(const AliMUONPadInfo &pad)
attach a pad to the cluster
const TMatrixD & GetCovariances() const
void SetTrackCharge(Short_t charge)
Set the muon charge.
void MUONClusterInfo(Int_t nevents=-1, const char *esdFileName="AliESDs.root", const char *inFileName="galice.root", const TString ocdbPath="local://$ALICE_ROOT/OCDB", const char *outFileName="clusterInfo.root")
class TMatrixT< Double_t > TMatrixD
void SetClusterId(UInt_t clusterId)
set cluster ID
static Int_t ManuMask(AliMp::PlaneType planeType)
AliMUONRecoParam * LoadRecoParam()
Definition: AliMUONCDB.cxx:535
TObjArray * GetTrackParamAtCluster() const
void SetPadXY(Double_t x, Double_t y)
Set pad coordinates (cm)
Double_t GetNonBendingSlope() const
return non bending slope (cm ** -1)