]> git.uio.no Git - u/mrichter/AliRoot.git/blame - MUON/AliMUONClusterDrawAZ.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Adding MuonSim.SetMakeTrigger(MUON); now required by the new CTP framework (Christian)
[u/mrichter/AliRoot.git] / MUON / AliMUONClusterDrawAZ.cxx
CommitLineData
1af223d7 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
d35a592d 16/* $Id$ */
17
d19b6003 18// -------------------------------------
b46cf82d 19// Class AliMUONClusterDrawAZ
20// -------------------------------------
21// Cluster drawing for AZ cluster finder
b46cf82d 22// Author: Alexander Zinchenko, JINR Dubna
1af223d7 23
24#include <stdlib.h>
25#include <Riostream.h>
26//#include <TROOT.h>
27#include <TCanvas.h>
28#include <TLine.h>
29//#include <TTree.h>
30#include <TH2.h>
31#include <TView.h>
32#include <TStyle.h>
33
34#include "AliMUONClusterDrawAZ.h"
35#include "AliMUONClusterFinderAZ.h"
0627f609 36#include "AliMUONGeometryModuleTransformer.h"
1af223d7 37#include "AliHeader.h"
38#include "AliRun.h"
39#include "AliMUON.h"
40//#include "AliMUONChamber.h"
41#include "AliMUONDigit.h"
42#include "AliMUONHit.h"
43#include "AliMUONRawCluster.h"
0627f609 44#include "AliMUONClusterInput.h"
1af223d7 45#include "AliMUONPixel.h"
46//#include "AliMC.h"
47#include "AliMUONLoader.h"
48#include "AliLog.h"
49
50ClassImp(AliMUONClusterDrawAZ)
51
52//_____________________________________________________________________________
53AliMUONClusterDrawAZ::AliMUONClusterDrawAZ()
54 : TObject()
55{
d19b6003 56/// Default constructor
1af223d7 57 fFind = NULL; fData = NULL;
58 for (Int_t i=0; i<4; i++) fHist[i] = NULL;
59}
60
61//_____________________________________________________________________________
62AliMUONClusterDrawAZ::AliMUONClusterDrawAZ(AliMUONClusterFinderAZ *clusFinder)
63 : TObject()
64{
d19b6003 65/// Constructor
1af223d7 66 fFind = clusFinder;
67 for (Int_t i=0; i<4; i++) fHist[i] = NULL;
68 fDebug = 1;
0627f609 69 fEvent = fChamber = fidDE = 0;
70 fModif = 0; //0;
1af223d7 71 Init();
72}
73
74//_____________________________________________________________________________
75AliMUONClusterDrawAZ::~AliMUONClusterDrawAZ()
76{
d19b6003 77/// Destructor
1af223d7 78}
79
80//_____________________________________________________________________________
81AliMUONClusterDrawAZ::AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs)
82 : TObject(rhs)
83{
d19b6003 84/// Protected copy constructor
1af223d7 85
86 AliFatal("Not implemented.");
87}
88
89
90//_____________________________________________________________________________
91AliMUONClusterDrawAZ&
92AliMUONClusterDrawAZ::operator=(const AliMUONClusterDrawAZ& rhs)
93{
d19b6003 94/// Protected assignement operator
1af223d7 95
96 if (this == &rhs) return *this;
97
98 AliFatal("Not implemented.");
99 return *this;
100}
101
102//_____________________________________________________________________________
103void AliMUONClusterDrawAZ::Init()
104{
d19b6003 105/// Initialization
1af223d7 106
107 TCanvas *c1 = new TCanvas("c1","Clusters",0,0,600,700);
108 //c1->SetFillColor(10);
109 c1->Divide(1,2);
110 new TCanvas("c2","Mlem",700,0,600,350);
111
112 // Get pointer to Alice detectors
113 //AliMUON *muon = (AliMUON*) gAlice->GetModule("MUON");
114 //if (!muon) return;
115 //Loaders
116 AliRunLoader *rl = AliRunLoader::GetRunLoader();
117 AliLoader *gime = rl->GetLoader("MUONLoader");
118 fData = ((AliMUONLoader*)gime)->GetMUONData();
119
120 gime->LoadHits("READ");
121 gime->LoadRecPoints("READ");
122}
123
124//_____________________________________________________________________________
125Bool_t AliMUONClusterDrawAZ::FindEvCh(Int_t nev, Int_t ch)
126{
d19b6003 127/// Find requested event and chamber (skip the ones before the selected)
1af223d7 128
129 if (nev < fEvent) return kFALSE;
0627f609 130 else if (nev == fEvent) {
131 if (ch < fChamber) return kFALSE;
132 if (AliMUONClusterInput::Instance()->DetElemId() < fidDE) return kFALSE;
133 }
1af223d7 134 fEvent = nev;
135 fChamber = ch;
0627f609 136 fidDE = AliMUONClusterInput::Instance()->DetElemId();
1af223d7 137 return kTRUE;
138}
139
140//_____________________________________________________________________________
141void AliMUONClusterDrawAZ::DrawCluster()
142{
d19b6003 143/// Draw preclusters
1af223d7 144
145 TCanvas *c1 = (TCanvas*) gROOT->GetListOfCanvases()->FindObject("c1");
146
147 cout << " nev " << fEvent << endl;
148
149 char hName[4];
150 for (Int_t cath = 0; cath < 2; cath++) {
151 // Build histograms
0627f609 152 //if (fHist[cath*2]) {fHist[cath*2]->Delete(); fHist[cath*2] = 0;}
153 //if (fHist[cath*2+1]) {fHist[cath*2+1]->Delete(); fHist[cath*2+1] = 0;}
154 if (fHist[cath*2]) fHist[cath*2] = 0;
155 if (fHist[cath*2+1]) fHist[cath*2+1] = 0;
1af223d7 156 if (fFind->GetNPads(cath) == 0) continue; // cluster on one cathode only
157 Float_t wxMin = 999, wxMax = 0, wyMin = 999, wyMax = 0;
158 Int_t minDx = 0, maxDx = 0, minDy = 0, maxDy = 0;
159 for (Int_t i = 0; i < fFind->GetNPads(0)+fFind->GetNPads(1); i++) {
160 if (fFind->GetIJ(0,i) != cath) continue;
161 if (fFind->GetXyq(3,i) < wxMin) { wxMin = fFind->GetXyq(3,i); minDx = i; }
162 if (fFind->GetXyq(3,i) > wxMax) { wxMax = fFind->GetXyq(3,i); maxDx = i; }
163 if (fFind->GetXyq(4,i) < wyMin) { wyMin = fFind->GetXyq(4,i); minDy = i; }
164 if (fFind->GetXyq(4,i) > wyMax) { wyMax = fFind->GetXyq(4,i); maxDy = i; }
165 }
166 cout << minDx << " " << maxDx << " " << minDy << " " << maxDy << endl;
167 Int_t nx, ny, padSize;
168 Float_t xmin = 9999, xmax = -9999, ymin = 9999, ymax = -9999;
169 if (TMath::Nint(fFind->GetXyq(3,minDx)*1000) == TMath::Nint(fFind->GetXyq(3,maxDx)*1000) &&
170 TMath::Nint(fFind->GetXyq(4,minDy)*1000) == TMath::Nint(fFind->GetXyq(4,maxDy)*1000)) {
171 // the same segmentation
172 cout << " Same" << endl;
173 cout << fFind->GetXyq(3,minDx) << " " << fFind->GetXyq(3,maxDx) << " "
174 << fFind->GetXyq(4,minDy) << " " << fFind->GetXyq(4,maxDy) << endl;
175 for (Int_t i = 0; i < fFind->GetNPads(0)+fFind->GetNPads(1); i++) {
176 if (fFind->GetIJ(0,i) != cath) continue;
177 if (fFind->GetXyq(0,i) < xmin) xmin = fFind->GetXyq(0,i);
178 if (fFind->GetXyq(0,i) > xmax) xmax = fFind->GetXyq(0,i);
179 if (fFind->GetXyq(1,i) < ymin) ymin = fFind->GetXyq(1,i);
180 if (fFind->GetXyq(1,i) > ymax) ymax = fFind->GetXyq(1,i);
181 }
182 xmin -= fFind->GetXyq(3,minDx); xmax += fFind->GetXyq(3,minDx);
183 ymin -= fFind->GetXyq(4,minDy); ymax += fFind->GetXyq(4,minDy);
184 nx = TMath::Nint ((xmax-xmin)/wxMin/2);
185 ny = TMath::Nint ((ymax-ymin)/wyMin/2);
186 cout << xmin << " " << xmax << " " << nx << " " << ymin << " " << ymax << " " << ny << endl;
187 sprintf(hName,"h%d",cath*2);
188 fHist[cath*2] = new TH2D(hName,"cluster",nx,xmin,xmax,ny,ymin,ymax);
189 for (Int_t i = 0; i < fFind->GetNPads(0)+fFind->GetNPads(1); i++) {
190 if (fFind->GetIJ(0,i) != cath) continue;
191 fHist[cath*2]->Fill(fFind->GetXyq(0,i),fFind->GetXyq(1,i),fFind->GetXyq(2,i));
1af223d7 192 }
193 } else {
194 // different segmentation in the cluster
195 cout << " Different" << endl;
196 cout << fFind->GetXyq(3,minDx) << " " << fFind->GetXyq(3,maxDx) << " "
197 << fFind->GetXyq(4,minDy) << " " << fFind->GetXyq(4,maxDy) << endl;
198 Int_t nOK = 0;
199 Int_t indx, locMin, locMax;
200 if (TMath::Nint(fFind->GetXyq(3,minDx)*1000) != TMath::Nint(fFind->GetXyq(3,maxDx)*1000)) {
201 // different segmentation along x
202 indx = 0;
203 locMin = minDx;
204 locMax = maxDx;
205 } else {
206 // different segmentation along y
207 indx = 1;
208 locMin = minDy;
209 locMax = maxDy;
210 }
211 Int_t loc = locMin;
212 for (Int_t i = 0; i < 2; i++) {
213 // loop over different pad sizes
214 if (i > 0) loc = locMax;
215 padSize = TMath::Nint(fFind->GetXyq(indx+3,loc)*1000);
216 xmin = 9999; xmax = -9999; ymin = 9999; ymax = -9999;
217 for (Int_t j = 0; j < fFind->GetNPads(0)+fFind->GetNPads(1); j++) {
218 if (fFind->GetIJ(0,j) != cath) continue;
219 if (TMath::Nint(fFind->GetXyq(indx+3,j)*1000) != padSize) continue;
220 nOK++;
221 xmin = TMath::Min (xmin,fFind->GetXyq(0,j));
222 xmax = TMath::Max (xmax,fFind->GetXyq(0,j));
223 ymin = TMath::Min (ymin,fFind->GetXyq(1,j));
224 ymax = TMath::Max (ymax,fFind->GetXyq(1,j));
225 }
226 xmin -= fFind->GetXyq(3,loc); xmax += fFind->GetXyq(3,loc);
227 ymin -= fFind->GetXyq(4,loc); ymax += fFind->GetXyq(4,loc);
228 nx = TMath::Nint ((xmax-xmin)/fFind->GetXyq(3,loc)/2);
229 ny = TMath::Nint ((ymax-ymin)/fFind->GetXyq(4,loc)/2);
230 sprintf(hName,"h%d",cath*2+i);
231 fHist[cath*2+i] = new TH2D(hName,"cluster",nx,xmin,xmax,ny,ymin,ymax);
232 for (Int_t j = 0; j < fFind->GetNPads(0)+fFind->GetNPads(1); j++) {
233 if (fFind->GetIJ(0,j) != cath) continue;
234 if (TMath::Nint(fFind->GetXyq(indx+3,j)*1000) != padSize) continue;
235 fHist[cath*2+i]->Fill(fFind->GetXyq(0,j),fFind->GetXyq(1,j),fFind->GetXyq(2,j));
236 }
237 } // for (Int_t i=0;
238 if (nOK != fFind->GetNPads(cath)) cout << " *** Too many segmentations: nPads, nOK "
239 << fFind->GetNPads(cath) << " " << nOK << endl;
240 } // if (TMath::Nint(fFind->GetXyq(3,minDx)*1000)
241 } // for (Int_t cath = 0;
242
243 // Draw histograms and coordinates
b46cf82d 244 //TH2D *hFake = 0x0;
245 TH2D *hFake = (TH2D*) gROOT->FindObject("hFake");
246 if (hFake) hFake->Delete();
d35a592d 247 if (fModif) {
248 // This part works only after a modification of THistPainter::PaintLego(Option_t *)
249 // in ROOT
250 Double_t xmin = 9999, ymin = 9999, xmax = -9999, ymax = -9999, aMax = -1;
251 for (Int_t i = 0; i < 4; i++) {
252 if (!fHist[i]) continue;
253 xmin = TMath::Min (xmin, fHist[i]->GetXaxis()->GetXmin());
254 xmax = TMath::Max (xmax, fHist[i]->GetXaxis()->GetXmax());
255 ymin = TMath::Min (ymin, fHist[i]->GetYaxis()->GetXmin());
256 ymax = TMath::Max (ymax, fHist[i]->GetYaxis()->GetXmax());
257 aMax = TMath:: Max (aMax, fHist[i]->GetMaximum());
258 }
b46cf82d 259 //if (c1->FindObject("hFake")) delete c1->FindObject("hFake");
260 hFake = new TH2D ("hFake", "hFake", 1, xmin, xmax, 1, ymin, ymax);
d35a592d 261 hFake->SetMaximum(aMax);
262 hFake->SetNdivisions(505,"Z");
263 hFake->SetStats(kFALSE);
264 }
265
266 TObject *stats = 0x0;
1af223d7 267 for (Int_t cath = 0; cath < 2; cath++) {
268 if (cath == 0) ModifyHistos();
269 if (fFind->GetNPads(cath) == 0) continue; // cluster on one cathode only
270 c1->cd(cath+1);
271 gPad->SetTheta(55);
272 gPad->SetPhi(30);
d35a592d 273 if (fModif) {
274 if (fHist[cath*2]) {
275 fHist[cath*2]->Draw();
276 gPad->Update();
277 stats = fHist[cath*2]->GetListOfFunctions()->FindObject("stats");
278 }
279 hFake->Draw("legoFb");
280 }
281
1af223d7 282 Double_t x, y, x0, y0, r1 = 999, r2 = 0;
283 if (fHist[cath*2+1]) {
284 //
285 x0 = fHist[cath*2]->GetXaxis()->GetXmin() - 1000*TMath::Cos(30*TMath::Pi()/180);
286 y0 = fHist[cath*2]->GetYaxis()->GetXmin() - 1000*TMath::Sin(30*TMath::Pi()/180);
287 r1 = 0;
288 Int_t ihist=cath*2;
289 for (Int_t iy = 1; iy <= fHist[ihist]->GetNbinsY(); iy++) {
290 y = fHist[ihist]->GetYaxis()->GetBinCenter(iy)
291 + fHist[ihist]->GetYaxis()->GetBinWidth(iy);
292 for (Int_t ix = 1; ix <= fHist[ihist]->GetNbinsX(); ix++) {
293 if (fHist[ihist]->GetCellContent(ix,iy) > 0.1) {
294 x = fHist[ihist]->GetXaxis()->GetBinCenter(ix)
295 + fHist[ihist]->GetXaxis()->GetBinWidth(ix);
296 r1 = TMath::Max (r1,TMath::Sqrt((x-x0)*(x-x0)+(y-y0)*(y-y0)));
297 }
298 }
299 }
300 ihist = cath*2 + 1 ;
301 for (Int_t iy = 1; iy <= fHist[ihist]->GetNbinsY(); iy++) {
302 y = fHist[ihist]->GetYaxis()->GetBinCenter(iy)
303 + fHist[ihist]->GetYaxis()->GetBinWidth(iy);
304 for (Int_t ix = 1; ix <= fHist[ihist]->GetNbinsX(); ix++) {
305 if (fHist[ihist]->GetCellContent(ix,iy) > 0.1) {
306 x = fHist[ihist]->GetXaxis()->GetBinCenter(ix)
307 + fHist[ihist]->GetXaxis()->GetBinWidth(ix);
308 r2 = TMath::Max (r2,TMath::Sqrt((x-x0)*(x-x0)+(y-y0)*(y-y0)));
309 }
310 }
311 }
312 cout << r1 << " " << r2 << endl;
313 } // if (fHist[cath*2+1])
314 if (r1 > r2) {
d35a592d 315 if (fModif) fHist[cath*2]->Draw("lego1FbSame");
316 else fHist[cath*2]->Draw("lego1Fb");
b46cf82d 317 // Draw background contaminated charges
318 //TH2D *hBkg = GetBackground(cath*2);
319 //if (hBkg) hBkg->Draw("lego1FbBbSameAxis");
1af223d7 320 if (fHist[cath*2+1]) fHist[cath*2+1]->Draw("lego1SameAxisBbFb");
321 } else {
d35a592d 322 if (fModif) fHist[cath*2+1]->Draw("lego1FbSame");
323 else fHist[cath*2+1]->Draw("lego1Fb");
1af223d7 324 fHist[cath*2]->Draw("lego1SameAxisFbBb");
325 }
326 c1->Update();
d35a592d 327 if (fModif) stats->Draw();
1af223d7 328 } // for (Int_t cath = 0;
329
330 // Draw simulated and reconstructed hits
331 DrawHits();
332}
333
334//_____________________________________________________________________________
335void AliMUONClusterDrawAZ::DrawHits()
336{
d19b6003 337/// Draw simulated and reconstructed hits
1af223d7 338
339 TView *view[2] = { 0x0, 0x0 };
0627f609 340 Double_t p1[3]={0}, p2[3], xNDC[6], xl, yl, zl;
b46cf82d 341 TLine *line[199] = {0};
1af223d7 342 TCanvas *c1 = (TCanvas*) gROOT->GetListOfCanvases()->FindObject("c1");
343 if (c1) {
344 c1->cd(1);
345 view[0] = c1->Pad()->GetView();
346 c1->cd(2);
347 view[1] = c1->Pad()->GetView();
348 }
349 fData->SetTreeAddress("H RC");
350
351 TH2D *hist = fHist[0] ? fHist[0] : fHist[2];
352 p2[2] = hist->GetMaximum();
353
354 // Draw simulated hits
355 cout << " *** Simulated hits *** " << endl;
0627f609 356 Int_t ntracks = 0;
357 if (fData->TreeH()) ntracks = (Int_t) fData->GetNtracks();
1af223d7 358 fnMu = 0;
359 Int_t ix, iy, iok, nLine = 0;
360 TClonesArray *hits = NULL;
361 for (Int_t i = 0; i < ntracks; i++) {
362 fData->GetTrack(i);
363 hits = fData->Hits();
364 Int_t nhits = (Int_t) hits->GetEntriesFast();
365 AliMUONHit* mHit;
366 for (Int_t ihit = 0; ihit < nhits; ihit++) {
367 mHit = (AliMUONHit*) hits->UncheckedAt(ihit);
368 if (mHit->Chamber() != fChamber+1) continue; // chamber number
b46cf82d 369 if (mHit->DetElemId() != fidDE) continue; // det. elem. Id
0627f609 370 AliMUONClusterInput::Instance()->Segmentation2(0)->GetTransformer()->
371 Global2Local(fidDE, mHit->X(), mHit->Y(), mHit->Z(), xl, yl, zl);
b46cf82d 372 //if (TMath::Abs(zl-fFind->GetZpad()) > 1) continue; // different slat
0627f609 373 p2[0] = p1[0] = xl; // x-pos of hit
374 p2[1] = p1[1] = yl; // y-pos
1af223d7 375 if (p1[0] < hist->GetXaxis()->GetXmin() ||
376 p1[0] > hist->GetXaxis()->GetXmax()) continue;
377 if (p1[1] < hist->GetYaxis()->GetXmin() ||
378 p1[1] > hist->GetYaxis()->GetXmax()) continue;
379 // Check if track comes thru pads with signal
380 iok = 0;
381 for (Int_t ihist = 0; ihist < 4; ihist++) {
382 if (!fHist[ihist]) continue;
383 ix = fHist[ihist]->GetXaxis()->FindBin(p1[0]);
384 iy = fHist[ihist]->GetYaxis()->FindBin(p1[1]);
385 if (fHist[ihist]->GetCellContent(ix,iy) > 0.5) {iok = 1; break;}
386 }
387 if (!iok) continue;
388 gStyle->SetLineColor(1);
389 if (TMath::Abs((Int_t)mHit->Particle()) == 13) {
390 gStyle->SetLineColor(4);
391 if (fnMu < 2) {
392 fxyMu[fnMu][0] = p1[0];
393 fxyMu[fnMu++][1] = p1[1];
394 }
395 }
0627f609 396 printf(" Local coord.: X=%10.4f, Y=%10.4f\n",p1[0],p1[1]);
397 printf(" Global coord.: X=%10.4f, Y=%10.4f, Z=%10.4f\n",mHit->X(),mHit->Y(),mHit->Z());
1af223d7 398 if (view[0] || view[1]) {
399 // Take into account track angles
400 p2[0] += mHit->Tlength() * TMath::Sin(mHit->Theta()/180*TMath::Pi())
401 * TMath::Cos(mHit->Phi()/180*TMath::Pi()) / 2;
402 p2[1] += mHit->Tlength() * TMath::Sin(mHit->Theta()/180*TMath::Pi())
403 * TMath::Sin(mHit->Phi()/180*TMath::Pi()) / 2;
404 for (Int_t ipad = 1; ipad < 3; ipad++) {
405 c1->cd(ipad);
d35a592d 406 if (!view[ipad-1]) continue;
1af223d7 407 view[ipad-1]->WCtoNDC(p1, &xNDC[0]);
408 view[ipad-1]->WCtoNDC(p2, &xNDC[3]);
409 //c1->DrawLine(xpad[0],xpad[1],xpad[3],xpad[4]);
410 line[nLine] = new TLine(xNDC[0],xNDC[1],xNDC[3],xNDC[4]);
411 line[nLine++]->Draw();
412 }
413 }
414 } // for (Int_t ihit = 0; ihit < nhits;
415 } // for (Int_t i = 0; i < ntracks;
b46cf82d 416 fData->ResetHits();
1af223d7 417
418 // Draw reconstructed coordinates
d35a592d 419 if (fData->TreeR()) fData->GetRawClusters();
1af223d7 420 TClonesArray *rawclust = fData->RawClusters(fChamber);
421 AliMUONRawCluster *mRaw;
422 gStyle->SetLineColor(3);
423 cout << " *** Reconstructed hits *** " << endl;
424 if (rawclust) {
425 for (Int_t i = 0; i < rawclust ->GetEntriesFast(); i++) {
426 mRaw = (AliMUONRawCluster*)rawclust ->UncheckedAt(i);
0627f609 427 AliMUONClusterInput::Instance()->Segmentation2(0)->GetTransformer()->
428 Global2Local(fidDE, mRaw->GetX(0), mRaw->GetY(0), mRaw->GetZ(0), xl, yl, zl);
429 if (TMath::Abs(zl-fFind->GetZpad()) > 1) continue; // different slat
430 p2[0] = p1[0] = xl; // x-pos of hit
431 p2[1] = p1[1] = yl; // y-pos
1af223d7 432 if (p1[0] < hist->GetXaxis()->GetXmin() ||
433 p1[0] > hist->GetXaxis()->GetXmax()) continue;
434 if (p1[1] < hist->GetYaxis()->GetXmin() ||
435 p1[1] > hist->GetYaxis()->GetXmax()) continue;
436 /*
437 treeD->GetEvent(cath);
438 cout << mRaw->fMultiplicity[0] << mRaw->fMultiplicity[1] << endl;
439 for (Int_t j=0; j<mRaw->fMultiplicity[cath]; j++) {
440 Int_t digit = mRaw->fIndexMap[j][cath];
441 cout << ((AliMUONDigit*)fMuonDigits->UncheckedAt(digit))->Signal() << endl;
442 }
443 */
444 // Check if track comes thru pads with signal
445 iok = 0;
446 for (Int_t ihist = 0; ihist < 4; ihist++) {
447 if (!fHist[ihist]) continue;
448 ix = fHist[ihist]->GetXaxis()->FindBin(p1[0]);
449 iy = fHist[ihist]->GetYaxis()->FindBin(p1[1]);
450 if (fHist[ihist]->GetCellContent(ix,iy) > 0.5) {iok = 1; break;}
451 }
452 if (!iok) continue;
0627f609 453 printf(" Local coord.: X=%10.4f, Y=%10.4f\n",p1[0],p1[1]);
454 printf(" Global coord.: X=%10.4f, Y=%10.4f, Z=%10.4f\n",mRaw->GetX(0),mRaw->GetY(0),mRaw->GetZ(0));
1af223d7 455 if (view[0] || view[1]) {
456 for (Int_t ipad = 1; ipad < 3; ipad++) {
457 c1->cd(ipad);
d35a592d 458 if (!view[ipad-1]) continue;
1af223d7 459 view[ipad-1]->WCtoNDC(p1, &xNDC[0]);
460 view[ipad-1]->WCtoNDC(p2, &xNDC[3]);
461 line[nLine] = new TLine(xNDC[0],xNDC[1],xNDC[3],xNDC[4]);
462 line[nLine++]->Draw();
463 }
464 }
465 } // for (Int_t i = 0; i < rawclust ->GetEntries();
466 } // if (rawclust)
b46cf82d 467 if (fData->TreeR()) fData->ResetRawClusters();
1af223d7 468 c1->Update();
469}
470
471//_____________________________________________________________________________
472Int_t AliMUONClusterDrawAZ::Next()
473{
d19b6003 474/// What to do next?
475
1af223d7 476 // File
477 FILE *lun = 0;
478 //lun = fopen("pull.dat","w");
479
480 for (Int_t i = 0; i < fnMu; i++) {
481 // Check again if muon comes thru the used pads (due to extra splitting)
482 for (Int_t j = 0; j < fFind->GetNPads(0)+fFind->GetNPads(1); j++) {
483 if (TMath::Abs(fxyMu[i][0]-fFind->GetXyq(0,j))<fFind->GetXyq(3,j) &&
484 TMath::Abs(fxyMu[i][1]-fFind->GetXyq(1,j))<fFind->GetXyq(4,j)) {
485 if (fDebug) printf("%12.3e %12.3e %12.3e %12.3e\n",fxyMu[i][2],fxyMu[i][3],fxyMu[i][4],fxyMu[i][5]);
486 if (lun) fprintf(lun,"%4d %2d %12.3e %12.3e %12.3e %12.3e\n",fEvent,fChamber,fxyMu[i][2],fxyMu[i][3],fxyMu[i][4],fxyMu[i][5]);
487 break;
488 }
489 }
490 } // for (Int_t i=0; i<fnMu;
491
492 // What's next?
493 char command[8];
494 cout << " What is next? " << endl;
495 command[0] = ' ';
496 gets(command);
0627f609 497 if (command[0] == 'n' || command[0] == 'N') { fEvent++; fChamber = fidDE = 0; } // next event
1af223d7 498 else if (command[0] == 'q' || command[0] == 'Q') { if (lun) fclose(lun); } // exit display
499 else if (command[0] == 'c' || command[0] == 'C') sscanf(command+1,"%d",&fChamber); // new chamber
0627f609 500 else if (command[0] == 'e' || command[0] == 'E') { sscanf(command+1,"%d",&fEvent); fChamber = fidDE = 0; } // new event
501 else if (command[0] == 'd' || command[0] == 'D') { sscanf(command+1,"%d",&fidDE); fChamber = fidDE / 100 - 1; } // new DetElem.
1af223d7 502 else return 1; // Next precluster
503 return 0;
504}
505
506
507//_____________________________________________________________________________
508void AliMUONClusterDrawAZ::ModifyHistos(void)
509{
d19b6003 510/// Modify histograms to bring them to (approximately) the same size
511
1af223d7 512 Int_t nhist = 0;
513 Float_t hlim[4][4], hbin[4][4]; // first index - xmin, xmax, ymin, ymax
514
515 Float_t binMin[4] = {999,999,999,999};
516
517 for (Int_t i = 0; i < 4; i++) {
518 if (!fHist[i]) {
519 hlim[0][i] = hlim[2][i] = 999;
520 hlim[1][i] = hlim[3][i] = -999;
521 continue;
522 }
523 hlim[0][i] = fHist[i]->GetXaxis()->GetXmin(); // xmin
524 hlim[1][i] = fHist[i]->GetXaxis()->GetXmax(); // xmax
525 hlim[2][i] = fHist[i]->GetYaxis()->GetXmin(); // ymin
526 hlim[3][i] = fHist[i]->GetYaxis()->GetXmax(); // ymax
527 hbin[0][i] = hbin[1][i] = fHist[i]->GetXaxis()->GetBinWidth(1);
528 hbin[2][i] = hbin[3][i] = fHist[i]->GetYaxis()->GetBinWidth(1);
529 binMin[0] = TMath::Min(binMin[0],hbin[0][i]);
530 binMin[2] = TMath::Min(binMin[2],hbin[2][i]);
531 nhist++;
532 }
533 binMin[1] = binMin[0];
534 binMin[3] = binMin[2];
535 cout << " Nhist: " << nhist << endl;
536
537 // Adjust histo limits for cathode with different segmentation
538 for (Int_t i = 0; i < 4; i+=2) {
539 if (!fHist[i+1]) continue;
540 Int_t imin, imax, i1 = i + 1;
541 for (Int_t lim = 0; lim < 4; lim++) {
542 while (1) {
543 if (hlim[lim][i] < hlim[lim][i1]) {
544 imin = i;
545 imax = i1;
546 } else {
547 imin = i1;
548 imax = i;
549 }
550 if (TMath::Abs(hlim[lim][imin]-hlim[lim][imax])<0.01*binMin[lim]) break;
551 if (lim == 0 || lim == 2) {
552 // find lower limit
553 hlim[lim][imax] -= hbin[lim][imax];
554 } else {
555 // find upper limit
556 hlim[lim][imin] += hbin[lim][imin];
557 }
558 } // while (1)
559 }
560 }
561
562
563 Int_t imnmx = 0, nExtra = 0;
564 for (Int_t lim = 0; lim < 4; lim++) {
565 if (lim == 0 || lim == 2) imnmx = TMath::LocMin(4,hlim[lim]); // find lower limit
566 else imnmx = TMath::LocMax(4,hlim[lim]); // find upper limit
567
568 // Adjust histogram limit
569 for (Int_t i = 0; i < 4; i++) {
570 if (!fHist[i]) continue;
571 nExtra = TMath::Nint ((hlim[lim][imnmx]-hlim[lim][i]) / hbin[lim][i]);
572 hlim[lim][i] += nExtra * hbin[lim][i];
573 }
574 }
575
576 // Rebuild histograms
577 TH2D *hist = 0;
578 Int_t nx, ny;
579 Double_t x, y, cont, cmax=0;
580 char hName[4];
581 for (Int_t ihist = 0; ihist < 4; ihist++) {
582 if (!fHist[ihist]) continue;
583 nx = TMath::Nint((hlim[1][ihist]-hlim[0][ihist])/hbin[0][ihist]);
584 ny = TMath::Nint((hlim[3][ihist]-hlim[2][ihist])/hbin[2][ihist]);
585 cout << ihist << " " << hlim[0][ihist] << " " << hlim[1][ihist] << " " << nx;
586 cout << " " << hlim[2][ihist] << " " << hlim[3][ihist] << " " << ny << endl;
587 sprintf(hName,"hh%d",ihist);
588 hist = new TH2D(hName,"hist",nx,hlim[0][ihist],hlim[1][ihist],ny,hlim[2][ihist],hlim[3][ihist]);
589 for (Int_t i=1; i<=fHist[ihist]->GetNbinsX(); i++) {
590 x = fHist[ihist]->GetXaxis()->GetBinCenter(i);
591 for (Int_t j=1; j<=fHist[ihist]->GetNbinsY(); j++) {
592 y = fHist[ihist]->GetYaxis()->GetBinCenter(j);
593 cont = fHist[ihist]->GetCellContent(i,j);
594 hist->Fill(x,y,cont);
595 }
596 }
597 cmax = TMath::Max (cmax,hist->GetMaximum());
598 sprintf(hName,"%s%d",fHist[ihist]->GetName(),ihist);
599 fHist[ihist]->Delete();
600 fHist[ihist] = new TH2D(*hist);
601 fHist[ihist]->SetName(hName);
602 fHist[ihist]->SetNdivisions(505,"Z");
603 hist->Delete();
604 }
605 if (fDebug) printf("%f \n",cmax);
606
607 for (Int_t ihist = 0; ihist < 4; ihist++) {
608 if (!fHist[ihist]) continue;
609 fHist[ihist]->SetMaximum(cmax);
610 fHist[ihist]->SetMinimum(0);
611 }
612}
613
614//_____________________________________________________________________________
615void AliMUONClusterDrawAZ::AdjustHist(Double_t *xylim, const AliMUONPixel *pixPtr)
616{
d19b6003 617/// Adjust histogram limits for pixel drawing
1af223d7 618
619 Float_t xypads[4];
620 if (fHist[0]) {
621 xypads[0] = fHist[0]->GetXaxis()->GetXmin();
622 xypads[1] = -fHist[0]->GetXaxis()->GetXmax();
623 xypads[2] = fHist[0]->GetYaxis()->GetXmin();
624 xypads[3] = -fHist[0]->GetYaxis()->GetXmax();
625 for (Int_t i = 0; i < 4; i++) {
626 while(1) {
627 if (xylim[i] < xypads[i]) break;
628 xylim[i] -= 2*pixPtr->Size(i/2);
629 }
630 }
631 }
632}
633
634//_____________________________________________________________________________
635void AliMUONClusterDrawAZ::DrawHist(const char* canvas, TH2D *hist)
636{
d19b6003 637/// Draw histogram in given canvas
1af223d7 638
639 Int_t ix = 0;
640 //((TCanvas*)gROOT->FindObject("c2"))->cd();
641 ((TCanvas*)gROOT->FindObject(canvas))->cd();
642 gPad->SetTheta(55);
643 gPad->SetPhi(30);
644 hist->Draw("lego1Fb");
645 gPad->Update();
0627f609 646 //gets((char*)&ix);
647 if (fnMu) gets((char*)&ix);
1af223d7 648}
649
650//_____________________________________________________________________________
651void AliMUONClusterDrawAZ::FillMuon(Int_t nfit, const Double_t *parOk, const Double_t *errOk)
652{
d19b6003 653/// Fill muon information
1af223d7 654
655 Int_t indx, imax;
656 Double_t cmax, rad;
657 for (Int_t i = 0; i < fnMu; i++) {
658 cmax = fxyMu[i][6];
659 for (Int_t j = 0; j < nfit; j++) {
660 indx = j<2 ? j*2 : j*2+1;
661 rad = (fxyMu[i][0]-parOk[indx])*(fxyMu[i][0]-parOk[indx]) +
662 (fxyMu[i][1]-parOk[indx+1])*(fxyMu[i][1]-parOk[indx+1]);
663 if (rad < cmax) {
664 cmax = rad;
665 imax = indx;
666 fxyMu[i][6] = cmax;
667 fxyMu[i][2] = parOk[imax] - fxyMu[i][0];
668 fxyMu[i][4] = parOk[imax+1] - fxyMu[i][1];
669 fxyMu[i][3] = errOk[imax];
670 fxyMu[i][5] = errOk[imax+1];
671 }
672 }
673 }
674}
675
d35a592d 676//_____________________________________________________________________________
677void AliMUONClusterDrawAZ::UpdateCluster(Int_t npad)
678{
d19b6003 679/// Update cluster after removing non-overlapped pads
d35a592d 680
681 Int_t cath = 0, ix = 0, iy = 0;
682 cout << " Update cluster " << endl;
683 gets((char*)&ix);
684 for (Int_t i = 0; i < npad; i++) {
685 if (TMath::Nint (fFind->GetXyq(2,i)) != -2) continue;
686 cath = fFind->GetIJ(0,i);
687 for (Int_t j = 0; j < 2; j++) {
688 Int_t ihist = cath * 2 + j;
689 if (!fHist[ihist]) continue;
690 ix = fHist[ihist]->GetXaxis()->FindBin(fFind->GetXyq(0,i));
691 iy = fHist[ihist]->GetYaxis()->FindBin(fFind->GetXyq(1,i));
692 Double_t cont = fHist[ihist]->GetCellContent(ix, iy);
693 if (cont < 0.1) continue;
694 fHist[ihist]->Fill(fFind->GetXyq(0,i), fFind->GetXyq(1,i), -cont);
695 }
696 }
697 TCanvas *c1 = (TCanvas*) gROOT->GetListOfCanvases()->FindObject("c1");
698 if (c1) {
699 c1->cd(1);
700 gPad->Modified();
701 gPad->Update();
702 c1->cd(2);
703 gPad->Modified();
704 gPad->Update();
705 }
706}
b46cf82d 707
708//_____________________________________________________________________________
709TH2D* AliMUONClusterDrawAZ::GetBackground(Int_t iHist)
710{
d19b6003 711/// Build histogram with pads from the cluster contaminated by the background
b46cf82d 712
713 //return 0x0;
714 Int_t cath = iHist / 2;
715 Double_t xmin = fHist[iHist]->GetXaxis()->GetXmin();
716 Double_t xmax = fHist[iHist]->GetXaxis()->GetXmax();
717 Double_t ymin = fHist[iHist]->GetYaxis()->GetXmin();
718 Double_t ymax = fHist[iHist]->GetYaxis()->GetXmax();
719
720 // Create histogram
721 char hName[4];
722 sprintf(hName,"Bkg%1d",iHist);
723 TH2D *hist = (TH2D*) gROOT->FindObject(hName);
724 if (hist) hist->Delete();
725 hist = (TH2D*) fHist[iHist]->Clone(hName);
726 hist->Reset();
727
728 // Loop over pads
729 Int_t digit = 0, iok = 0, ix = 0, iy = 0;
730 AliMUONDigit *mdig = 0x0;
731 Double_t cont = 0, x = 0, y = 0;
732 for (Int_t i = 0; i < fFind->GetNPads(0)+fFind->GetNPads(1); i++) {
733 if (fFind->GetIJ(0,i) != cath) continue;
734 x = fFind->GetXyq(0,i);
735 y = fFind->GetXyq(1,i);
736 if (x < xmin || x > xmax) continue;
737 if (y < ymin || y > ymax) continue;
738 digit = fFind->GetIJ(4,i);
739 if (digit >= 0) mdig = AliMUONClusterInput::Instance()->Digit(cath, digit);
740 else mdig = AliMUONClusterInput::Instance()->Digit(TMath::Even(cath), -digit-1);
741 if (mdig->Track(1) >= 0 || mdig->Track(0) >= 10000000) {
742 ix = fHist[iHist]->GetXaxis()->FindBin(x);
743 iy = fHist[iHist]->GetYaxis()->FindBin(y);
744 cont = fHist[iHist]->GetCellContent(ix, iy);
745 hist->Fill(x, y, cont);
746 iok = 1;
747 }
748 }
749 if (iok) {
750 hist->SetFillColor(5);
751 hist->SetMaximum(fHist[iHist]->GetMaximum());
752 return hist;
753 }
754 return 0x0;
755}