]>
Commit | Line | Data |
---|---|---|
cc87ebcd | 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 | ||
d19b6003 | 18 | // -------------------------- |
19 | // Class AliMUONDetElement | |
20 | // -------------------------- | |
21 | // Detection element object containing information for combined | |
22 | // cluster / track finder in MUON arm | |
23 | // Author: Alexander Zinchenko, JINR Dubna | |
24 | ||
25 | ||
cc87ebcd | 26 | #include <TObjArray.h> |
27 | #include <TClonesArray.h> | |
28 | #include "AliMUONDetElement.h" | |
29 | #include "AliMUON.h" | |
30 | #include "AliMUONSegmentation.h" | |
31 | #include "AliMUONDigit.h" | |
32 | #include "AliMUONHitMapA1.h" | |
cc87ebcd | 33 | #include "AliMUONRawCluster.h" |
34 | #include "AliMUONHitForRec.h" | |
35 | #include "AliMUONClusterInput.h" | |
36 | #include "AliMUONClusterFinderAZ.h" | |
37 | #include "AliRun.h" | |
38 | #include "AliLog.h" | |
39 | ||
40 | ClassImp(AliMUONDetElement) // Class implementation in ROOT context | |
cc87ebcd | 41 | |
42 | //_________________________________________________________________________ | |
43 | AliMUONDetElement::AliMUONDetElement() | |
54d7ba50 | 44 | : TObject(), |
45 | fidDE(0), | |
46 | fIndex(0), | |
47 | fChamber(0), | |
48 | fZ(0.), | |
49 | fNHitsForRec(0), | |
50 | fRawClus(0x0), | |
51 | fHitsForRec(0x0), | |
52 | fRecModel(0x0) | |
cc87ebcd | 53 | { |
d19b6003 | 54 | /// Default constructor |
cc87ebcd | 55 | for (Int_t i = 0; i < 2; i++) { |
56 | fHitMap[i] = NULL; | |
57 | fDigits[i] = NULL; | |
58 | fSeg[i] = NULL; | |
59 | } | |
cc87ebcd | 60 | } |
61 | ||
62 | //_________________________________________________________________________ | |
63 | AliMUONDetElement::AliMUONDetElement(Int_t idDE, AliMUONDigit *dig, AliMUONClusterFinderAZ *recModel) | |
54d7ba50 | 64 | : TObject(), |
65 | fidDE(idDE), | |
66 | fIndex(0), | |
67 | fChamber(idDE / 100 - 1), | |
68 | fZ(0.), | |
69 | fNHitsForRec(0), | |
70 | fRawClus(0x0), | |
71 | fHitsForRec(0x0), | |
72 | fRecModel(recModel) | |
cc87ebcd | 73 | { |
d19b6003 | 74 | /// Constructor |
cc87ebcd | 75 | fDigits[0] = new TObjArray(10); |
76 | fDigits[1] = new TObjArray(10); | |
77 | fRawClus = new TObjArray(10); | |
78 | fHitsForRec = new TClonesArray("AliMUONHitForRec",10); | |
cc87ebcd | 79 | AliMUON *pMUON = (AliMUON*) gAlice->GetModule("MUON"); |
80 | AliMUONSegmentation *pSegmentation = pMUON->GetSegmentation(); | |
c2a43efa | 81 | fSeg[0] = pSegmentation->GetModuleSegmentationByDEId(fidDE, 0); |
82 | fSeg[1] = pSegmentation->GetModuleSegmentationByDEId(fidDE, 1); | |
cc87ebcd | 83 | Float_t x, y, z; |
84 | fSeg[dig->Cathode()]->GetPadC(fidDE, dig->PadX(), dig->PadY(), x, y, z); | |
85 | fZ = z; | |
86 | AddDigit(dig); | |
87 | } | |
88 | ||
89 | //_________________________________________________________________________ | |
90 | AliMUONDetElement::~AliMUONDetElement() | |
91 | { | |
d19b6003 | 92 | /// Destructor |
cc87ebcd | 93 | for (Int_t i = 0; i < 2; i++) { |
94 | delete fHitMap[i]; fHitMap[i] = NULL; | |
95 | delete fDigits[i]; fDigits[i] = NULL; | |
96 | } | |
97 | if (fRawClus) { fRawClus->Delete(); delete fRawClus; fRawClus = 0; } | |
98 | //if (fRawClus) { delete fRawClus; fRawClus = 0; } | |
99 | delete fHitsForRec; fHitsForRec = 0; | |
100 | } | |
101 | ||
cc87ebcd | 102 | //_________________________________________________________________________ |
103 | Int_t AliMUONDetElement::Compare(const TObject* detElem) const | |
104 | { | |
d19b6003 | 105 | /// "Compare" function to sort in Z (towards interaction point) |
106 | /// Returns -1 (0, +1) if charge of current pixel | |
107 | /// is greater than (equal to, less than) charge of pixel | |
cc87ebcd | 108 | if (fZ > ((AliMUONDetElement*)detElem)->Z()) return(+1); |
109 | else if (fZ == ((AliMUONDetElement*)detElem)->Z()) return( 0); | |
110 | else return(-1); | |
111 | } | |
112 | ||
113 | //_________________________________________________________________________ | |
114 | void AliMUONDetElement::Fill(AliMUONData */*data*/) | |
115 | { | |
d19b6003 | 116 | /// Fill hit maps |
cc87ebcd | 117 | fLeft[0] = fDigits[0]->GetEntriesFast(); |
118 | fLeft[1] = fDigits[1]->GetEntriesFast(); | |
119 | ||
4e92ede3 | 120 | Int_t npx0 = fSeg[0]->Npx(fidDE)+1; |
121 | Int_t npy0 = fSeg[0]->Npy(fidDE)+1; | |
122 | fHitMap[0] = new AliMUONHitMapA1(npx0, npy0, fDigits[0]); | |
cc87ebcd | 123 | fHitMap[0]->FillHits(); |
4e92ede3 | 124 | |
125 | Int_t npx1 = fSeg[1]->Npx(fidDE)+1; | |
126 | Int_t npy1 = fSeg[1]->Npy(fidDE)+1; | |
127 | fHitMap[1] = new AliMUONHitMapA1(npx1, npy1, fDigits[1]); | |
cc87ebcd | 128 | fHitMap[1]->FillHits(); |
129 | ||
130 | // The part below is just for debugging (fill rec. points already found) | |
131 | /* | |
132 | fLeft[0] = fLeft[1] = 0; | |
133 | TClonesArray *rawClus = data->RawClusters(fChamber); | |
134 | cout << rawClus << " " << rawClus->GetEntriesFast() << endl; | |
135 | for (Int_t i = 0; i < rawClus->GetEntriesFast(); i++) { | |
136 | AliMUONRawCluster *recP = (AliMUONRawCluster*) rawClus->UncheckedAt(i); | |
137 | cout << fChamber << " " << recP->GetZ(0) << " " << recP->GetZ(1) << " " << fZ << endl; | |
138 | if (TMath::Abs(recP->GetZ(0)-fZ) > 0.5) continue; | |
139 | if (!Inside(recP->GetX(0), recP->GetY(0), recP->GetZ(0))) continue; | |
140 | AddHitForRec(recP); // add hit for rec. | |
141 | rawClus->RemoveAt(i); // remove | |
142 | } | |
143 | cout << fHitsForRec->GetEntriesFast() << endl; | |
144 | rawClus->Compress(); | |
145 | */ | |
146 | } | |
147 | ||
148 | //_________________________________________________________________________ | |
149 | void AliMUONDetElement::AddDigit(AliMUONDigit *dig) | |
150 | { | |
d19b6003 | 151 | /// Add digit |
cc87ebcd | 152 | |
153 | fDigits[dig->Cathode()]->Add(dig); | |
154 | } | |
155 | ||
156 | //_________________________________________________________________________ | |
157 | Bool_t AliMUONDetElement::Inside(Double_t x, Double_t y, Double_t z) const | |
158 | { | |
d19b6003 | 159 | /// Check if point is inside detection element |
cc87ebcd | 160 | |
161 | Int_t ix, iy; | |
162 | for (Int_t i = 0; i < 2; i++) { | |
163 | if (!fSeg[i]) continue; | |
164 | fSeg[i]->GetPadI(fidDE, x, y, z, ix, iy); | |
165 | //cout << x << " " << y << " " << z << " " << fChamber << " " << ix << " " << iy << " " << fSeg[i]->Npx(fidDE) << " " << fSeg[i]->Npy(fidDE) /*<< " " << fSeg[i]->GetPadI(fidDE, x, y, z, ix, iy)*/ << endl; | |
166 | if (ix > 0 && iy > 0 && ix <= fSeg[i]->Npx(fidDE) && iy <= fSeg[i]->Npy(fidDE)) return kTRUE; | |
167 | } | |
168 | // Check for edge effect (extrapolated track "right outside" det. elem. boundaries (+- 1cm in X and Y) | |
169 | for (Int_t i = 0; i < 2; i++) { | |
170 | if (!fSeg[i]) continue; | |
171 | for (Int_t idx = -1; idx < 2; idx++) { | |
172 | Double_t x1 = x + 1. * idx; | |
173 | for (Int_t idy = -1; idy < 2; idy++) { | |
174 | if (idx == 0 && idy == 0) continue; | |
175 | Double_t y1 = y + 1. * idy; | |
176 | fSeg[i]->GetPadI(fidDE, x1, y1, z, ix, iy); | |
177 | //cout << x1 << " " << y1 << " " << z << " " << fChamber << " " << ix << " " << iy << " " << fSeg[i]->Npx(fidDE) << " " << fSeg[i]->Npy(fidDE) /*<< " " << fSeg[i]->GetPadI(fidDE, x, y, z, ix, iy)*/ << endl; | |
178 | if (ix > 0 && iy > 0 && ix <= fSeg[i]->Npx(fidDE) && iy <= fSeg[i]->Npy(fidDE)) return kTRUE; | |
179 | } | |
180 | } | |
181 | } | |
182 | return kFALSE; | |
183 | } | |
184 | ||
185 | //_________________________________________________________________________ | |
186 | void AliMUONDetElement::ClusterReco(Double_t xTrack, Double_t yTrack) | |
187 | { | |
d19b6003 | 188 | /// Run cluster reconstruction around point (x,y) |
cc87ebcd | 189 | |
190 | if (fLeft[0] == 0 && fLeft[1] == 0) return; // all digits have been used | |
191 | Float_t dx, dy; | |
192 | dx = dy = 5; // 5 cm for now | |
193 | AliMUONClusterInput::Instance()->SetDigits(fChamber, fidDE, | |
194 | (TClonesArray*)fDigits[0], (TClonesArray*)fDigits[1]); | |
195 | ||
196 | // Mark used pads | |
197 | for (Int_t cath = 0; cath < 2; cath++) { | |
198 | if (fDigits[cath]->GetEntriesFast() == 0) continue; // empty cathode | |
199 | for (Int_t i = 0; i < fDigits[cath]->GetEntriesFast(); i++) { | |
200 | if (fLeft[cath] == 0) { fRecModel->SetUsed(cath,i); continue; } | |
201 | AliMUONDigit *dig = (AliMUONDigit*) fDigits[cath]->UncheckedAt(i); | |
202 | //cout << i << " " << dig->PadX() << " " << dig->PadY() << " " << fHitMap[cath]->TestHit(dig->PadX(), dig->PadY()) << endl; | |
203 | if (fHitMap[cath]->TestHit(dig->PadX(), dig->PadY()) == kUsed) fRecModel->SetUsed(cath,i); | |
204 | else fRecModel->SetUnused(cath,i); | |
205 | } | |
206 | } | |
207 | ||
208 | fRecModel->ResetRawClusters(); | |
209 | ||
210 | for (Int_t cath = 0; cath < 2; cath++) { | |
211 | if (fDigits[cath]->GetEntriesFast() == 0) continue; // empty cathode | |
212 | // Loop over pads | |
213 | for (fSeg[cath]->FirstPad(fidDE, xTrack, yTrack, fZ, dx, dy); | |
214 | fSeg[cath]->MorePads(fidDE); | |
215 | fSeg[cath]->NextPad(fidDE)) { | |
216 | if (fLeft[cath] == 0) break; | |
217 | //cout << cath << " " << fSeg[cath]->Ix() << " " << fSeg[cath]->Iy() << " " << fSeg[cath]->DetElemId() << " " << fHitMap[cath]->TestHit(fSeg[cath]->Ix(), fSeg[cath]->Iy()) << endl; | |
218 | if (fHitMap[cath]->TestHit(fSeg[cath]->Ix(), fSeg[cath]->Iy()) == kEmpty || | |
219 | fHitMap[cath]->TestHit(fSeg[cath]->Ix(), fSeg[cath]->Iy()) == kUsed) continue; | |
220 | ||
221 | // Set starting pad | |
222 | for (Int_t j = 0; j < fDigits[cath]->GetEntriesFast(); j++) { | |
223 | AliMUONDigit *dig = (AliMUONDigit*) fDigits[cath]->UncheckedAt(j); | |
224 | if (dig->PadX() != fSeg[cath]->Ix() || dig->PadY() != fSeg[cath]->Iy()) continue; | |
225 | //cout << fidDE << " " << j << " " << fSeg[cath]->Ix() << " " << fSeg[cath]->Iy() << endl; | |
226 | fRecModel->SetStart(cath, j); | |
227 | break; | |
228 | } | |
229 | ||
230 | fRecModel->FindRawClusters(); | |
231 | Int_t nClusEnd = fRecModel->GetRawClusters()->GetEntriesFast(); | |
232 | //cout << " ***nclus: " << nClusEnd << endl; | |
233 | for (Int_t i = 0; i < nClusEnd; i++) { | |
234 | AliMUONRawCluster *clus = (AliMUONRawCluster*) fRecModel->GetRawClusters()->UncheckedAt(i); | |
235 | AddHitForRec(clus); // add hit for rec. | |
236 | //cout << clus->GetX(0) << " " << clus->GetY(0) << endl; | |
237 | } | |
238 | // Mark used pads | |
239 | for (Int_t cath1 = 0; cath1 < 2; cath1++) { | |
240 | for (Int_t j = 0; j < fDigits[cath1]->GetEntriesFast(); j++) { | |
241 | if (fLeft[cath1] == 0) break; | |
242 | AliMUONDigit *dig = (AliMUONDigit*) fDigits[cath1]->UncheckedAt(j); | |
243 | Float_t x, y, z; | |
244 | fSeg[cath1]->GetPadC(fidDE,dig->PadX(),dig->PadY(),x,y,z); | |
245 | //cout << "clus " << cath1 << " " << fLeft[cath1] << " " << dig->PadX() << " " << dig->PadY() << " " << x << " " << y << " " << z << " " << fRecModel->GetUsed(cath1,j) << endl; | |
246 | if (!fRecModel->GetUsed(cath1,j)) continue; | |
247 | if (fHitMap[cath1]->TestHit(dig->PadX(), dig->PadY()) == kUsed) continue; | |
248 | fHitMap[cath1]->FlagHit(dig->PadX(), dig->PadY()); | |
85fec35d | 249 | AliDebug(10,Form(" %d %d %d %d \n", cath1, fidDE, dig->PadX(), dig->PadY())); |
cc87ebcd | 250 | fLeft[cath1]--; |
251 | } | |
252 | } | |
253 | } // for (fSeg[cath]->FirstPad(... | |
254 | } // for (Int_t cath = 0; | |
255 | } | |
256 | ||
257 | //_________________________________________________________________________ | |
258 | void AliMUONDetElement::AddHitForRec(AliMUONRawCluster *clus) | |
259 | { | |
d19b6003 | 260 | /// Make HitForRec from raw cluster (rec. point) |
cc87ebcd | 261 | |
262 | fRawClus->Add(new AliMUONRawCluster(*clus)); | |
263 | AliMUONHitForRec *hitForRec = | |
264 | new ((*fHitsForRec)[fNHitsForRec++]) AliMUONHitForRec(clus); | |
265 | ||
266 | // more information into HitForRec | |
267 | // resolution: info should be already in raw cluster and taken from it ???? | |
268 | hitForRec->SetBendingReso2(-1); //fBendingResolution * fBendingResolution); | |
269 | hitForRec->SetNonBendingReso2(-1); //fNonBendingResolution * fNonBendingResolution); | |
270 | // original raw cluster | |
271 | hitForRec->SetChamberNumber(fChamber); | |
272 | hitForRec->SetZ(clus->GetZ(0)); | |
273 | //hitForRec->SetHitNumber(-(fIndex+1)*100000-fNHitsForRec+1); | |
274 | hitForRec->SetHitNumber(-(fIndex+1)*100000-fRawClus->GetEntriesFast()+1); | |
275 | //delete clus; // for now | |
276 | } | |
277 | ||
278 | /* | |
279 | //_________________________________________________________________________ | |
280 | Int_t AliMUONDetElement::GetMapElem(AliMUONDigit *digit) | |
281 | { | |
282 | Int_t cath = digit->Cathode(); | |
283 | return 0; | |
284 | ||
285 | } | |
286 | ||
287 | //_________________________________________________________________________ | |
288 | void AliMUONDetElement::SetMapElem(const AliMUONDigit *digit, Int_t flag) | |
289 | { | |
290 | Int_t cath = digit->Cathode(); | |
291 | } | |
292 | */ |