1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
17 ///////////////////////////////////////////////////////////////////////////////
19 // Class to analyse tracks for calibration //
20 // to be used as a component in AliTPCSelectorTracks //
21 // In the constructor you have to specify name and title //
22 // to get the Object out of a file. //
23 // The parameter 'clusterParam', a AliTPCClusterParam object //
24 // (needed for TPC cluster error and shape parameterization) //
25 // Normally you get this object out of the file 'TPCClusterParam.root' //
26 // In the parameter 'cuts' the cuts are specified, that decide //
27 // weather a track will be accepted for calibration or not. //
33 Raw Data -> Local Reconstruction -> Tracking -> Calibration -> RefData (component itself)
34 Offline/HLT Offline/HLT OCDB entries (AliTPCClusterParam)
38 ///////////////////////////////////////////////////////////////////////////////
52 //#include <TPDGCode.h>
54 #include "TLinearFitter.h"
55 //#include "TMatrixD.h"
56 #include "TTreeStream.h"
59 #include <TGraph2DErrors.h>
60 #include "TPostScript.h"
66 #include <TCollection.h>
68 #include <TLinearFitter.h>
74 #include "AliTracker.h"
76 #include "AliESDtrack.h"
77 #include "AliESDfriend.h"
78 #include "AliESDfriendTrack.h"
79 #include "AliTPCseed.h"
80 #include "AliTPCclusterMI.h"
81 #include "AliTPCROC.h"
83 #include "AliTPCParamSR.h"
84 #include "AliTrackPointArray.h"
85 #include "AliTPCcalibTracks.h"
86 #include "AliTPCClusterParam.h"
87 #include "AliTPCcalibTracksCuts.h"
88 #include "AliTPCCalPadRegion.h"
89 #include "AliTPCCalPad.h"
90 #include "AliTPCCalROC.h"
92 #include "TPaveText.h"
96 //#include "TThread.h"
98 //#include "TLockFile.h"
101 ClassImp(AliTPCcalibTracks)
104 AliTPCcalibTracks::AliTPCcalibTracks():
114 fArrayChargeVsDriftlength(0),
115 fcalPadRegionChargeVsDriftlength(0),
124 fRejectedTracksHisto(0),
125 fHclusterPerPadrow(0),
126 fHclusterPerPadrowRaw(0),
128 fCalPadClusterPerPad(0),
129 fCalPadClusterPerPadRaw(0),
138 // AliTPCcalibTracks default constructor
141 if (GetDebugLevel() > 0) cout << "AliTPCcalibTracks' default constructor called" << endl;
146 AliTPCcalibTracks::AliTPCcalibTracks(const AliTPCcalibTracks& calibTracks):
147 AliTPCcalibBase(calibTracks),
156 fArrayChargeVsDriftlength(0),
157 fcalPadRegionChargeVsDriftlength(0),
166 fRejectedTracksHisto(0),
167 fHclusterPerPadrow(0),
168 fHclusterPerPadrowRaw(0),
170 fCalPadClusterPerPad(0),
171 fCalPadClusterPerPadRaw(0),
180 // AliTPCcalibTracks copy constructor
182 if (GetDebugLevel() > 0) cout << " ***** this is AliTPCcalibTracks' copy constructor ***** " << endl;
184 Bool_t dirStatus = TH1::AddDirectoryStatus();
185 TH1::AddDirectory(kFALSE);
188 // backward compatibility: if the data member doesn't yet exist, it will not be merged
189 (calibTracks.fArrayAmpRow) ? length = calibTracks.fArrayAmpRow->GetEntriesFast() : length = -1;
190 fArrayAmpRow = new TObjArray(length);
191 fArrayAmp = new TObjArray(length);
192 for (Int_t i = 0; i < length; i++) {
193 fArrayAmpRow->AddAt( (TProfile*)calibTracks.fArrayAmpRow->At(i)->Clone(), i);
194 fArrayAmp->AddAt( ((TProfile*)calibTracks.fArrayAmp->At(i)->Clone()), i);
197 (calibTracks.fArrayQDY) ? length = calibTracks.fArrayQDY->GetEntriesFast() : length = -1;
198 fArrayQDY= new TObjArray(length);
199 fArrayQDZ= new TObjArray(length);
200 fArrayQRMSY= new TObjArray(length);
201 fArrayQRMSZ= new TObjArray(length);
202 for (Int_t i = 0; i < length; i++) {
203 fArrayQDY->AddAt( ((TH1F*)calibTracks.fArrayQDY->At(i)->Clone()), i);
204 fArrayQDZ->AddAt( ((TH1F*)calibTracks.fArrayQDZ->At(i)->Clone()), i);
205 fArrayQRMSY->AddAt( ((TH1F*)calibTracks.fArrayQRMSY->At(i)->Clone()), i);
206 fArrayQRMSZ->AddAt( ((TH1F*)calibTracks.fArrayQRMSZ->At(i)->Clone()), i);
209 (calibTracks.fResolY) ? length = calibTracks.fResolY->GetEntriesFast() : length = -1;
210 fResolY = new TObjArray(length);
211 fResolZ = new TObjArray(length);
212 fRMSY = new TObjArray(length);
213 fRMSZ = new TObjArray(length);
214 for (Int_t i = 0; i < length; i++) {
215 fResolY->AddAt( ((TH1F*)calibTracks.fResolY->At(i)->Clone()), i);
216 fResolZ->AddAt( ((TH1F*)calibTracks.fResolZ->At(i)->Clone()), i);
217 fRMSY->AddAt( ((TH1F*)calibTracks.fRMSY->At(i)->Clone()), i);
218 fRMSZ->AddAt( ((TH1F*)calibTracks.fRMSZ->At(i)->Clone()), i);
221 (calibTracks.fArrayChargeVsDriftlength) ? length = calibTracks.fArrayChargeVsDriftlength->GetEntriesFast() : length = -1;
222 (calibTracks.fArrayChargeVsDriftlength) ? fArrayChargeVsDriftlength = new TObjArray(length) : fArrayChargeVsDriftlength = 0;
223 for (Int_t i = 0; i < length; i++) {
224 fArrayChargeVsDriftlength->AddAt( ((TProfile*)calibTracks.fArrayChargeVsDriftlength->At(i)->Clone()), i);
227 fDeltaY = (TH1F*)calibTracks.fDeltaY->Clone();
228 fDeltaZ = (TH1F*)calibTracks.fDeltaZ->Clone();
229 fHclus = (TH1I*)calibTracks.fHclus->Clone();
230 fClusterCutHisto = (TH2I*)calibTracks.fClusterCutHisto->Clone();
231 fRejectedTracksHisto = (TH1I*)calibTracks.fRejectedTracksHisto->Clone();
232 fHclusterPerPadrow = (TH1I*)calibTracks.fHclusterPerPadrow->Clone();
233 fHclusterPerPadrowRaw = (TH1I*)calibTracks.fHclusterPerPadrowRaw->Clone();
234 fcalPadRegionChargeVsDriftlength = (AliTPCCalPadRegion*)calibTracks.fcalPadRegionChargeVsDriftlength->Clone();
235 fCalPadClusterPerPad = (AliTPCCalPad*)calibTracks.fCalPadClusterPerPad->Clone();
236 fCalPadClusterPerPadRaw = (AliTPCCalPad*)calibTracks.fCalPadClusterPerPadRaw->Clone();
238 fCuts = new AliTPCcalibTracksCuts(calibTracks.fCuts->GetMinClusters(), calibTracks.fCuts->GetMinRatio(),
239 calibTracks.fCuts->GetMax1pt(), calibTracks.fCuts->GetEdgeYXCutNoise(), calibTracks.fCuts->GetEdgeThetaCutNoise());
240 SetNameTitle(calibTracks.GetName(), calibTracks.GetTitle());
241 TH1::AddDirectory(dirStatus); // set status back to original status
242 // cout << "+++++ end of copy constructor +++++" << endl; // TO BE REMOVED
246 AliTPCcalibTracks & AliTPCcalibTracks::operator=(const AliTPCcalibTracks& calibTracks){
248 // assgnment operator
250 if (this != &calibTracks) {
251 new (this) AliTPCcalibTracks(calibTracks);
258 AliTPCcalibTracks::AliTPCcalibTracks(const Text_t *name, const Text_t *title, AliTPCClusterParam *clusterParam, AliTPCcalibTracksCuts* cuts, Int_t logLevel) :
268 fArrayChargeVsDriftlength(0),
269 fcalPadRegionChargeVsDriftlength(0),
278 fRejectedTracksHisto(0),
279 fHclusterPerPadrow(0),
280 fHclusterPerPadrowRaw(0),
282 fCalPadClusterPerPad(0),
283 fCalPadClusterPerPadRaw(0),
292 // AliTPCcalibTracks constructor
293 // specify 'name' and 'title' of your object
294 // specify 'clusterParam', (needed for TPC cluster error and shape parameterization)
295 // In the parameter 'cuts' the cuts are specified, that decide
296 // weather a track will be accepted for calibration or not.
298 // fDebugLevel - debug output: -1: silence, 0: default, 1: things like constructor called, 5: write fDebugStreamer, 6: waste your screen
300 // All histograms are instatiated in this constructor.
303 this->SetTitle(title);
305 if (GetDebugLevel() > 0) cout << " ***** this is AliTPCcalibTracks' main constructor ***** " << endl;
306 G__SetCatchException(0);
308 fClusterParam = clusterParam;
310 fClusterParam->SetInstance(fClusterParam);
313 Error("AliTPCcalibTracks","No cluster parametrization found! A valid clusterParam object is needed in the constructor. (To be found in 'TPCClusterParam.root'.)");
316 SetDebugLevel(logLevel);
318 TH1::AddDirectory(kFALSE);
323 fHclus = new TH1I("hclus","Number of clusters per track",160, 0, 160); // valgrind 3
324 fRejectedTracksHisto = new TH1I("RejectedTracksHisto", "Rejected tracks, sorted by failed cut", 10, 1, 10);
325 fHclusterPerPadrow = new TH1I("fHclusterPerPadrow", " clusters per padRow, used for the resolution tree", 160, 0, 160);
326 fHclusterPerPadrowRaw = new TH1I("fHclusterPerPadrowRaw", " clusters per padRow, before cutting clusters", 160, 0, 160);
327 fCalPadClusterPerPad = new AliTPCCalPad("fCalPadClusterPerPad", "clusters per pad");
328 fCalPadClusterPerPadRaw = new AliTPCCalPad("fCalPadClusterPerPadRaw", "clusters per pad, before cutting clusters");
329 fClusterCutHisto = new TH2I("fClusterCutHisto", "Cutted cluster over padRow; Cut Criterium; PadRow", 5,1,5, 160,0,159);
331 // Amplitude - sector - row histograms
332 fArrayAmpRow = new TObjArray(72);
333 fArrayAmp = new TObjArray(72);
334 fArrayChargeVsDriftlength = new TObjArray(72);
336 for (Int_t i = 0; i < 36; i++){
337 sprintf(chname,"Amp_row_Sector%d",i);
338 prof1 = new TProfile(chname,chname,63,0,64); // valgrind 3 193,536 bytes in 354 blocks are still reachable
339 prof1->SetXTitle("Pad row");
340 prof1->SetYTitle("Mean Max amplitude");
341 fArrayAmpRow->AddAt(prof1,i);
342 sprintf(chname,"Amp_row_Sector%d",i+36);
343 prof1 = new TProfile(chname,chname,96,0,97); // valgrind 3 3,912 bytes in 6 blocks are possibly lost
344 prof1->SetXTitle("Pad row");
345 prof1->SetYTitle("Mean Max amplitude");
346 fArrayAmpRow->AddAt(prof1,i+36);
349 sprintf(chname,"Amp_Sector%d",i);
350 his1 = new TH1F(chname,chname,250,0,500); // valgrind
351 his1->SetXTitle("Max Amplitude (ADC)");
352 fArrayAmp->AddAt(his1,i);
353 sprintf(chname,"Amp_Sector%d",i+36);
354 his1 = new TH1F(chname,chname,200,0,600); // valgrind 3 13,408,208 bytes in 229 blocks are still reachable
355 his1->SetXTitle("Max Amplitude (ADC)");
356 fArrayAmp->AddAt(his1,i+36);
359 sprintf(chname, "driftlengt vs. charge, ROC %i", i);
360 prof1 = new TProfile(chname, chname, 500, 0, 250);
361 prof1->SetYTitle("Charge");
362 prof1->SetXTitle("Driftlength");
363 fArrayChargeVsDriftlength->AddAt(prof1,i);
364 sprintf(chname, "driftlengt vs. charge, ROC %i", i+36);
365 prof1 = new TProfile(chname, chname, 500, 0, 250);
366 prof1->SetYTitle("Charge");
367 prof1->SetXTitle("Driftlength");
368 fArrayChargeVsDriftlength->AddAt(prof1,i+36);
371 TH1::AddDirectory(kFALSE);
373 fDeltaY = new TH1F("DeltaY","DeltaY",100,-1,1);
374 fDeltaZ = new TH1F("DeltaZ","DeltaZ",100,-1,1);
376 fResolY = new TObjArray(3);
377 fResolZ = new TObjArray(3);
378 fRMSY = new TObjArray(3);
379 fRMSZ = new TObjArray(3);
382 his3D = new TH3F("Resol Y0","Resol Y0", 5,20,250, 4, 0,1., 50, -1,1);
383 fResolY->AddAt(his3D,0);
384 his3D = new TH3F("Resol Y1","Resol Y1", 5,20,250, 4, 0,1., 50, -1,1);
385 fResolY->AddAt(his3D,1);
386 his3D = new TH3F("Resol Y2","Resol Y2", 5,20,250, 4, 0,0.8, 50, -1,1);
387 fResolY->AddAt(his3D,2);
389 his3D = new TH3F("Resol Z0","Resol Z0", 5,20,250, 4, 0,1, 50, -1,1);
390 fResolZ->AddAt(his3D,0);
391 his3D = new TH3F("Resol Z1","Resol Z1", 5,20,250, 4, 0,1, 50, -1,1);
392 fResolZ->AddAt(his3D,1);
393 his3D = new TH3F("Resol Z2","Resol Z2", 5,20,250, 4, 0,1, 50, -1,1);
394 fResolZ->AddAt(his3D,2);
396 his3D = new TH3F("RMS Y0","RMS Y0", 5,20,250, 4, 0,1., 50, 0,0.8);
397 fRMSY->AddAt(his3D,0);
398 his3D = new TH3F("RMS Y1","RMS Y1", 5,20,250, 4, 0,1., 50, 0,0.8);
399 fRMSY->AddAt(his3D,1);
400 his3D = new TH3F("RMS Y2","RMS Y2", 5,20,250, 4, 0,0.8, 50, 0,0.8);
401 fRMSY->AddAt(his3D,2);
403 his3D = new TH3F("RMS Z0","RMS Z0", 5,20,250, 4, 0,1, 50, 0,0.8);
404 fRMSZ->AddAt(his3D,0);
405 his3D = new TH3F("RMS Z1","RMS Z1", 5,20,250, 4, 0,1, 50, 0,0.8);
406 fRMSZ->AddAt(his3D,1);
407 his3D = new TH3F("RMS Z2","RMS Z2", 5,20,250, 4, 0,1, 50, 0,0.8);
408 fRMSZ->AddAt(his3D,2);
411 TH1::AddDirectory(kFALSE);
413 fArrayQDY = new TObjArray(300);
414 fArrayQDZ = new TObjArray(300);
415 fArrayQRMSY = new TObjArray(300);
416 fArrayQRMSZ = new TObjArray(300);
417 for (Int_t iq = 0; iq <= 10; iq++){
418 for (Int_t ipad = 0; ipad < 3; ipad++){
419 Int_t bin = GetBin(iq, ipad);
420 Float_t qmean = GetQ(bin);
422 sprintf(name,"ResolY Pad%d Qmiddle%f",ipad, qmean);
423 his3D = new TH3F(name, name, 20,10,250, 20, 0,1.5, 50, -1,1);
424 fArrayQDY->AddAt(his3D, bin);
425 sprintf(name,"ResolZ Pad%d Qmiddle%f",ipad, qmean);
426 his3D = new TH3F(name, name, 20,10,250, 20, 0,1.5, 50, -1,1);
427 fArrayQDZ->AddAt(his3D, bin);
428 sprintf(name,"RMSY Pad%d Qmiddle%f",ipad, qmean);
429 his3D = new TH3F(name, name, 20,10,250, 20, 0,1.5, 50, 0,1);
430 fArrayQRMSY->AddAt(his3D, bin);
431 sprintf(name,"RMSZ Pad%d Qmiddle%f",ipad, qmean);
432 his3D = new TH3F(name, name, 20,10,250, 20, 0,1.5, 50, 0,1);
433 fArrayQRMSZ->AddAt(his3D, bin);
437 fcalPadRegionChargeVsDriftlength = new AliTPCCalPadRegion("fcalPadRegionChargeVsDriftlength", "TProfiles with charge vs driftlength for each pad region");
439 for (UInt_t padSize = 0; padSize < 3; padSize++) {
440 for (UInt_t isector = 0; isector < 36; isector++) {
441 if (padSize == 0) sprintf(chname, "driftlengt vs. charge, sector %i, short pads", isector);
442 if (padSize == 1) sprintf(chname, "driftlengt vs. charge, sector %i, medium pads", isector);
443 if (padSize == 2) sprintf(chname, "driftlengt vs. charge, sector %i, long pads", isector);
444 tempProf = new TProfile(chname, chname, 500, 0, 250);
445 tempProf->SetYTitle("Charge");
446 tempProf->SetXTitle("Driftlength");
447 fcalPadRegionChargeVsDriftlength->SetObject(tempProf, isector, padSize);
451 fFitterLinY1 = new TLinearFitter (2,"pol1");
452 fFitterLinZ1 = new TLinearFitter (2,"pol1");
453 fFitterLinY2 = new TLinearFitter (2,"pol1");
454 fFitterLinZ2 = new TLinearFitter (2,"pol1");
455 fFitterParY = new TLinearFitter (3,"pol2");
456 fFitterParZ = new TLinearFitter (3,"pol2");
458 if (GetDebugLevel() > 1) cout << "AliTPCcalibTracks object sucessfully constructed: " << GetName() << endl;
459 cout << "end of main constructor" << endl; // TO BE REMOVED
463 AliTPCcalibTracks::~AliTPCcalibTracks() {
465 // AliTPCcalibTracks destructor
468 if (GetDebugLevel() > 0) cout << "AliTPCcalibTracks' destuctor called." << endl;
470 if (fArrayAmpRow) length = fArrayAmpRow->GetEntriesFast();
471 for (Int_t i = 0; i < length; i++){
472 delete fArrayAmpRow->At(i);
473 delete fArrayAmp->At(i);
481 if (fResolY) length = fResolY->GetEntriesFast();
482 for (Int_t i = 0; i < length; i++){
483 delete fResolY->At(i);
484 delete fResolZ->At(i);
493 if (fArrayQDY) length = fArrayQDY->GetEntriesFast();
494 for (Int_t i = 0; i < length; i++){
495 delete fArrayQDY->At(i);
496 delete fArrayQDZ->At(i);
497 delete fArrayQRMSY->At(i);
498 delete fArrayQRMSZ->At(i);
501 if (fArrayChargeVsDriftlength) length = fArrayChargeVsDriftlength->GetEntriesFast();
502 for (Int_t i = 0; i < length; i++){
503 delete fArrayChargeVsDriftlength->At(i);
517 delete fArrayChargeVsDriftlength;
520 delete fRejectedTracksHisto;
521 delete fClusterCutHisto;
522 delete fHclusterPerPadrow;
523 delete fHclusterPerPadrowRaw;
524 if (fCalPadClusterPerPad) delete fCalPadClusterPerPad;
525 if (fCalPadClusterPerPadRaw) delete fCalPadClusterPerPadRaw;
526 fcalPadRegionChargeVsDriftlength->Delete();
527 delete fcalPadRegionChargeVsDriftlength;
531 void AliTPCcalibTracks::AddInfo(TChain * chain, char* fileName){
533 // Add the neccessary information for processing to the chain
534 // (cluster parametrization)
536 TFile clusterParamFile(fileName);
537 AliTPCClusterParam *clusterParam = (AliTPCClusterParam *) clusterParamFile.Get("Param");
538 chain->GetUserInfo()->AddLast((TObject*)clusterParam);
539 cout << "Clusterparametrization added to the chain." << endl;
542 void AliTPCcalibTracks::Process(AliTPCseed *track){
544 // To be called in the selector
545 // first AcceptTrack is evaluated, then calls all the following analyse functions:
546 // FillResolutionHistoLocal(track)
547 // AlignUpDown(track, esd)
549 if (GetDebugLevel() > 5) Info("Process","Starting to process the track...");
550 Int_t accpetStatus = AcceptTrack(track);
551 if (accpetStatus == 0) {
552 FillResolutionHistoLocal(track);
553 // AlignUpDown(track, esd);
555 else fRejectedTracksHisto->Fill(accpetStatus);
560 Int_t AliTPCcalibTracks::GetBin(Float_t q, Int_t pad){
562 // calculate bins for given q and pad type
565 Int_t res = TMath::Max( TMath::Nint((TMath::Sqrt(q) - 3.)), 0 );
572 Int_t AliTPCcalibTracks::GetBin(Int_t iq, Int_t pad){
574 // calculate bins for given iq and pad type
577 return iq * 3 + pad;;
581 Float_t AliTPCcalibTracks::GetQ(Int_t bin){
583 // returns to bin belonging charge
586 Int_t bin0 = bin / 3;
592 Float_t AliTPCcalibTracks::GetPad(Int_t bin){
594 // returns to bin belonging pad
602 Int_t AliTPCcalibTracks::AcceptTrack(AliTPCseed * track){
604 // Function, that decides wheather a given track is accepted for
605 // the analysis or not.
606 // The cuts are specified in the AliTPCcalibTracksCuts object 'fCuts'
607 // Returns 0 if a track is accepted or an integer different from 0
608 // to indicate the failed cut
610 const Int_t kMinClusters = fCuts->GetMinClusters();
611 const Float_t kMinRatio = fCuts->GetMinRatio();
612 const Float_t kMax1pt = fCuts->GetMax1pt();
613 const Float_t kEdgeYXCutNoise = fCuts->GetEdgeYXCutNoise();
614 const Float_t kEdgeThetaCutNoise = fCuts->GetEdgeThetaCutNoise();
617 // edge induced noise tracks - NEXT RELEASE will be removed during tracking
618 if ( TMath::Abs(track->GetY() / track->GetX()) > kEdgeYXCutNoise )
619 if ( TMath::Abs(track->GetTgl()) < kEdgeThetaCutNoise ) return 1;
620 if (track->GetNumberOfClusters() < kMinClusters) return 2;
621 Float_t ratio = track->GetNumberOfClusters() / (track->GetNFoundable() + 1.);
622 if (ratio < kMinRatio) return 3;
623 // Float_t mpt = track->Get1Pt(); // Get1Pt() doesn't exist any more
624 Float_t mpt = track->GetSigned1Pt();
625 if (TMath::Abs(mpt) > kMax1pt) return 4;
626 //if (TMath::Abs(track->GetZ())>240.) return kFALSE;
627 //if (TMath::Abs(track->GetZ())<10.) return kFALSE;
628 //if (TMath::Abs(track->GetTgl())>0.03) return kFALSE;
630 if (GetDebugLevel() > 5) Info("AcceptTrack","Track has been accepted.");
635 void AliTPCcalibTracks::FillResolutionHistoLocal(AliTPCseed * track){
637 // fill resolution histograms - localy - tracklet in the neighborhood
638 // write debug information to 'TPCSelectorDebug.root'
640 // _ the main function, called during track analysis _
642 // loop over all padrows along the track
643 // fit tracklets (length: 13 clusters) calculate mean chi^2 for this track-fit in Y and Z direction
645 // loop again over all padrows along the track
646 // fit tracklet (clusters in given padrow +- kDelta padrows)
647 // with polynom of 2nd order and two polynoms of 1st order
648 // take both polynoms of 1st order, calculate difference of their parameters
649 // add covariance matrixes and calculate chi2 of this difference
650 // if this chi2 is bigger than a given threshold, assume that the current cluster is
651 // a kink an goto next padrow
653 // fill fArrayAmpRow, array with amplitudes vs. row for given sector
654 // fill fArrayAmp, array with amplitude histograms for give sector
655 // fill fRMSY, fRMSZ, fArrayQRMSY and fArrayQRMSZ, fDeltaY, fDeltaZ, fResolY, fResolZ, fArrayQDY, fArrayQDY
657 // write debug information to 'TPCSelectorDebug.root'
658 // only for every kDeltaWriteDebugStream'th padrow to reduce data volume
659 // and to avoid redundant data
662 if (GetDebugLevel() > 5) Info("FillResolutionHistoLocal"," ***** Start of FillResolutionHistoLocal *****");
663 const Int_t kDelta = 10; // delta rows to fit
664 const Float_t kMinRatio = 0.75; // minimal ratio
665 const Float_t kCutChi2 = 6.; // cut chi2 - left right - kink removal
666 const Float_t kErrorFraction = 0.5; // use only clusters with small interpolation error - for error param
667 const Int_t kFirstLargePad = 127; // medium pads -> long pads
668 const Float_t kLargePadSize = 1.5; // factor between medium and long pads' area
669 const Int_t kDeltaWriteDebugStream = 5; // only for every kDeltaWriteDebugStream'th padrow debug information is calulated and written to debugstream
676 TMatrixD matrixY0(2,2);
677 TMatrixD matrixZ0(2,2);
678 TMatrixD matrixY1(2,2);
679 TMatrixD matrixZ1(2,2);
681 // estimate mean error
682 Int_t nTrackletsAll = 0; // number of tracklets for given track
683 Float_t csigmaY = 0; // mean sigma for tracklet refit in Y direction
684 Float_t csigmaZ = 0; // mean sigma for tracklet refit in Z direction
685 Int_t nClusters = 0; // working variable, number of clusters per tracklet
686 Int_t sectorG = -1; // working variable, sector of tracklet, has to stay constant for one tracklet
688 fHclus->Fill(track->GetNumberOfClusters()); // for statistics overview
689 // ---------------------------------------------------------------------
690 for (Int_t irow = 0; irow < 159; irow++){
691 // loop over all rows along the track
692 // fit tracklets (length: 13 rows) with pol2 in Y and Z direction
693 // calculate mean chi^2 for this track-fit in Y and Z direction
694 AliTPCclusterMI * cluster0 = track->GetClusterPointer(irow);
695 if (!cluster0) continue; // no cluster found
696 Int_t sector = cluster0->GetDetector();
697 fHclusterPerPadrowRaw->Fill(irow);
699 Int_t ipad = TMath::Nint(cluster0->GetPad());
700 Float_t value = fCalPadClusterPerPadRaw->GetCalROC(sector)->GetValue((sector<36)?irow:irow-64, TMath::Nint(cluster0->GetPad()));
701 fCalPadClusterPerPadRaw->GetCalROC(sector)->SetValue((sector<36)?irow:irow-64, ipad, value + 1 );
703 if (sector != sectorG){
704 // track leaves sector before it crossed enough rows to fit / initialization
706 fFitterParY->ClearPoints();
707 fFitterParZ->ClearPoints();
712 Double_t x = cluster0->GetX();
713 fFitterParY->AddPoint(&x, cluster0->GetY(), 1);
714 fFitterParZ->AddPoint(&x, cluster0->GetZ(), 1);
716 if ( nClusters >= kDelta + 3 ){
717 // if more than 13 (kDelta+3) clusters were added to the fitters
718 // fit the tracklet, increase trackletCounter
722 csigmaY += fFitterParY->GetChisquare() / (nClusters - 3.);
723 csigmaZ += fFitterParZ->GetChisquare() / (nClusters - 3.);
725 fFitterParY->ClearPoints();
726 fFitterParZ->ClearPoints();
729 } // for (Int_t irow = 0; irow < 159; irow++)
730 // mean chi^2 for all tracklet fits in Y and in Z direction:
731 csigmaY = TMath::Sqrt(csigmaY / nTrackletsAll);
732 csigmaZ = TMath::Sqrt(csigmaZ / nTrackletsAll);
733 // ---------------------------------------------------------------------
735 for (Int_t irow = 0; irow < 159; irow++){
736 // loop again over all rows along the track
739 Int_t nclFound = 0; // number of clusters in the neighborhood
740 Int_t ncl0 = 0; // number of clusters in rows < rowOfCenterCluster
741 Int_t ncl1 = 0; // number of clusters in rows > rowOfCenterCluster
742 AliTPCclusterMI * cluster0 = track->GetClusterPointer(irow);
743 if (!cluster0) continue;
744 Int_t sector = cluster0->GetDetector();
745 Float_t xref = cluster0->GetX();
748 fFitterParY->ClearPoints();
749 fFitterParZ->ClearPoints();
750 fFitterLinY1->ClearPoints();
751 fFitterLinZ1->ClearPoints();
752 fFitterLinY2->ClearPoints();
753 fFitterLinZ2->ClearPoints();
755 // fit tracklet (clusters in given padrow +- kDelta padrows)
756 // with polynom of 2nd order and two polynoms of 1st order
757 // take both polynoms of 1st order, calculate difference of their parameters
758 // add covariance matrixes and calculate chi2 of this difference
759 // if this chi2 is bigger than a given threshold, assume that the current cluster is
760 // a kink an goto next padrow
762 for (Int_t idelta = -kDelta; idelta <= kDelta; idelta++){
763 // loop over irow +- kDelta rows (neighboured rows)
766 if (idelta == 0) continue; // don't use center cluster
767 if (idelta + irow < 0 || idelta + irow > 159) continue; // don't go out of ROC
768 AliTPCclusterMI * currentCluster = track->GetClusterPointer(irow + idelta);
769 if (!currentCluster) continue;
770 if (currentCluster->GetType() < 0) continue;
771 if (currentCluster->GetDetector() != sector) continue;
772 Double_t x = currentCluster->GetX() - xref; // x = differece: current cluster - cluster @ irow
776 fFitterLinY1->AddPoint(&x, currentCluster->GetY(), csigmaY);
777 fFitterLinZ1->AddPoint(&x, currentCluster->GetZ(), csigmaZ);
781 fFitterLinY2->AddPoint(&x, currentCluster->GetY(), csigmaY);
782 fFitterLinZ2->AddPoint(&x, currentCluster->GetZ(), csigmaZ);
784 fFitterParY->AddPoint(&x, currentCluster->GetY(), csigmaY);
785 fFitterParZ->AddPoint(&x, currentCluster->GetZ(), csigmaZ);
786 } // loop over neighbourhood for fitter filling
788 if (nclFound < kDelta * kMinRatio) fRejectedTracksHisto->Fill(10);
789 if (nclFound < kDelta * kMinRatio) fClusterCutHisto->Fill(1, irow);
790 if (nclFound < kDelta * kMinRatio) continue; // if not enough clusters (7.5) found in neighbourhood goto next padrow
793 Double_t chi2 = (fFitterParY->GetChisquare() + fFitterParZ->GetChisquare()) / (2. * nclFound - 6.);
794 if (chi2 > kCutChi2) fRejectedTracksHisto->Fill(9);
795 if (chi2 > kCutChi2) fClusterCutHisto->Fill(2, irow);
796 if (chi2 > kCutChi2) continue; // if chi^2 is too big goto next padrow
799 // only when there are enough clusters (4) in each direction
801 fFitterLinY1->Eval();
802 fFitterLinZ1->Eval();
805 fFitterLinY2->Eval();
806 fFitterLinZ2->Eval();
809 if (ncl0 > 4 && ncl1 > 4){
810 fFitterLinY1->GetCovarianceMatrix(matrixY0);
811 fFitterLinY2->GetCovarianceMatrix(matrixY1);
812 fFitterLinZ1->GetCovarianceMatrix(matrixZ0);
813 fFitterLinZ2->GetCovarianceMatrix(matrixZ1);
814 fFitterLinY2->GetParameters(paramY1);
815 fFitterLinZ2->GetParameters(paramZ1);
816 fFitterLinY1->GetParameters(paramY0);
817 fFitterLinZ1->GetParameters(paramZ0);
820 matrixY0 += matrixY1;
821 matrixZ0 += matrixZ1;
824 TMatrixD difY(2, 1, paramY0.GetMatrixArray());
825 TMatrixD difYT(1, 2, paramY0.GetMatrixArray());
827 TMatrixD mulY(matrixY0, TMatrixD::kMult, difY);
828 TMatrixD chi2Y(difYT, TMatrixD::kMult, mulY);
831 TMatrixD difZ(2, 1, paramZ0.GetMatrixArray());
832 TMatrixD difZT(1, 2, paramZ0.GetMatrixArray());
834 TMatrixD mulZ(matrixZ0, TMatrixD::kMult, difZ);
835 TMatrixD chi2Z(difZT, TMatrixD::kMult, mulZ);
839 if (chi2 * 0.25 > kCutChi2) fRejectedTracksHisto->Fill(8);
840 if (chi2 * 0.25 > kCutChi2) fClusterCutHisto->Fill(3, irow);
841 if (chi2 * 0.25 > kCutChi2) continue; // if chi2 is too big goto next padrow
842 // fit tracklet with polynom of 2nd order and two polynoms of 1st order
843 // take both polynoms of 1st order, calculate difference of their parameters
844 // add covariance matrixes and calculate chi2 of this difference
845 // if this chi2 is bigger than a given threshold, assume that the current cluster is
846 // a kink an goto next padrow
849 // current padrow has no kink
851 // get fit parameters from pol2 fit:
852 Double_t paramY[4], paramZ[4];
853 paramY[0] = fFitterParY->GetParameter(0);
854 paramY[1] = fFitterParY->GetParameter(1);
855 paramY[2] = fFitterParY->GetParameter(2);
856 paramZ[0] = fFitterParZ->GetParameter(0);
857 paramZ[1] = fFitterParZ->GetParameter(1);
858 paramZ[2] = fFitterParZ->GetParameter(2);
860 Double_t tracky = paramY[0];
861 Double_t trackz = paramZ[0];
862 Float_t deltay = tracky - cluster0->GetY();
863 Float_t deltaz = trackz - cluster0->GetZ();
864 Float_t angley = paramY[1] - paramY[0] / xref;
865 Float_t anglez = paramZ[1];
867 Float_t max = cluster0->GetMax();
868 UInt_t isegment = cluster0->GetDetector() % 36;
869 Int_t padSize = 0; // short pads
870 if (cluster0->GetDetector() >= 36) {
871 padSize = 1; // medium pads
872 if (cluster0->GetRow() > 63) padSize = 2; // long pads
875 // =========================================
876 // wirte collected information to histograms
877 // =========================================
879 TProfile *profAmpRow = (TProfile*)fArrayAmpRow->At(sector);
880 if ( irow >= kFirstLargePad) max /= kLargePadSize;
881 profAmpRow->Fill( (Double_t)cluster0->GetRow(), max );
882 TH1F *hisAmp = (TH1F*)fArrayAmp->At(sector);
885 // remove the following two lines one day:
886 TProfile *profDriftLength = (TProfile*)fArrayChargeVsDriftlength->At(sector);
887 profDriftLength->Fill( 250.-(Double_t)TMath::Abs(cluster0->GetZ()), max );
889 TProfile *profDriftLengthTmp = (TProfile*)(fcalPadRegionChargeVsDriftlength->GetObject(isegment, padSize));
890 profDriftLengthTmp->Fill( 250.-(Double_t)TMath::Abs(cluster0->GetZ()), max );
892 fHclusterPerPadrow->Fill(irow); // fill histogram showing clusters per padrow
893 Int_t ipad = TMath::Nint(cluster0->GetPad());
894 Float_t value = fCalPadClusterPerPad->GetCalROC(sector)->GetValue((sector<36)?irow:irow-64, TMath::Nint(cluster0->GetPad()));
895 fCalPadClusterPerPad->GetCalROC(sector)->SetValue((sector<36)?irow:irow-64, ipad, value + 1 );
899 his3 = (TH3F*)fRMSY->At(padSize);
900 if (his3) his3->Fill(250 - TMath::Abs(cluster0->GetZ()), TMath::Abs(angley), TMath::Sqrt(cluster0->GetSigmaY2()) );
901 his3 = (TH3F*)fRMSZ->At(padSize);
902 if (his3) his3->Fill( 250 - TMath::Abs(cluster0->GetZ()), TMath::Abs(anglez), TMath::Sqrt(cluster0->GetSigmaZ2()) );
904 his3 = (TH3F*)fArrayQRMSY->At(GetBin(cluster0->GetMax(), padSize));
905 if (his3) his3->Fill( 250 - TMath::Abs(cluster0->GetZ()), TMath::Abs(angley), TMath::Sqrt(cluster0->GetSigmaY2()) );
906 his3 = (TH3F*)fArrayQRMSZ->At(GetBin(cluster0->GetMax(), padSize));
907 if (his3) his3->Fill( 250 - TMath::Abs(cluster0->GetZ()), TMath::Abs(anglez), TMath::Sqrt(cluster0->GetSigmaZ2()) );
910 // Fill resolution histograms
911 Bool_t useForResol = kTRUE;
912 if (fFitterParY->GetParError(0) > kErrorFraction * csigmaY) useForResol = kFALSE;
915 fDeltaY->Fill(deltay);
916 fDeltaZ->Fill(deltaz);
917 his3 = (TH3F*)fResolY->At(padSize);
918 if (his3) his3->Fill( 250 - TMath::Abs(cluster0->GetZ()), TMath::Abs(angley), deltay );
919 his3 = (TH3F*)fResolZ->At(padSize);
920 if (his3) his3->Fill( 250 - TMath::Abs(cluster0->GetZ()), TMath::Abs(anglez), deltaz );
921 his3 = (TH3F*)fArrayQDY->At(GetBin(cluster0->GetMax(), padSize));
922 if (his3) his3->Fill( 250 - TMath::Abs(cluster0->GetZ()),TMath::Abs(angley), deltay );
923 his3 = (TH3F*)fArrayQDZ->At(GetBin(cluster0->GetMax(), padSize));
924 if (his3) his3->Fill( 250 - TMath::Abs(cluster0->GetZ()),TMath::Abs(anglez), deltaz );
927 //=============================================================================================
929 if (useForResol && nclFound > 2 * kMinRatio * kDelta
930 && irow % kDeltaWriteDebugStream == 0 && GetDebugLevel() > 4){
931 if (GetDebugLevel() > 5) Info("FillResolutionHistoLocal","Filling 'TPCSelectorDebug.root', irow = %i", irow);
932 FillResolutionHistoLocalDebugPart(track, cluster0, irow, angley, anglez, nclFound, kDelta);
933 } // if (useForResol && nclFound > 2 * kMinRatio * kDelta)
935 } // loop over all padrows along the track: for (Int_t irow = 0; irow < 159; irow++)
936 } // FillResolutionHistoLocal(...)
940 void AliTPCcalibTracks::FillResolutionHistoLocalDebugPart(AliTPCseed *track, AliTPCclusterMI *cluster0, Int_t irow, Float_t angley, Float_t anglez, Int_t nclFound, Int_t kDelta) {
942 // - debug part of FillResolutionHistoLocal -
943 // called only for every kDeltaWriteDebugStream'th padrow, to avoid to much redundant data
944 // called only for GetStreamLevel() > 4
945 // fill resolution trees
948 Int_t sector = cluster0->GetDetector();
949 Float_t xref = cluster0->GetX();
950 Int_t padSize = 0; // short pads
951 if (cluster0->GetDetector() >= 36) {
952 padSize = 1; // medium pads
953 if (cluster0->GetRow() > 63) padSize = 2; // long pads
956 static TLinearFitter fitY0(3, "pol2");
957 static TLinearFitter fitZ0(3, "pol2");
958 static TLinearFitter fitY2(5, "hyp4");
959 static TLinearFitter fitZ2(5, "hyp4");
960 static TLinearFitter fitY2Q(5, "hyp4");
961 static TLinearFitter fitZ2Q(5, "hyp4");
962 static TLinearFitter fitY2S(5, "hyp4");
963 static TLinearFitter fitZ2S(5, "hyp4");
968 fitY2Q.ClearPoints();
969 fitZ2Q.ClearPoints();
970 fitY2S.ClearPoints();
971 fitZ2S.ClearPoints();
973 for (Int_t idelta = -kDelta; idelta <= kDelta; idelta++){
974 // loop over irow +- kDelta rows (neighboured rows)
977 if (idelta == 0) continue;
978 if (idelta + irow < 0 || idelta + irow > 159) continue; // don't go out of ROC
979 AliTPCclusterMI * cluster = track->GetClusterPointer(irow + idelta);
980 if (!cluster) continue;
981 if (cluster->GetType() < 0) continue;
982 if (cluster->GetDetector() != sector) continue;
983 Double_t x = cluster->GetX() - xref;
984 Double_t sigmaY0 = fClusterParam->GetError0Par( 0, padSize, (250.0 - TMath::Abs(cluster->GetZ())), TMath::Abs(angley) );
985 Double_t sigmaZ0 = fClusterParam->GetError0Par( 1, padSize, (250.0 - TMath::Abs(cluster->GetZ())), TMath::Abs(anglez) );
987 Double_t sigmaYQ = fClusterParam->GetErrorQPar( 0, padSize, (250.0 - TMath::Abs(cluster->GetZ())), TMath::Abs(angley), TMath::Abs(cluster->GetMax()) );
988 Double_t sigmaZQ = fClusterParam->GetErrorQPar( 1, padSize, (250.0 - TMath::Abs(cluster->GetZ())), TMath::Abs(anglez), TMath::Abs(cluster->GetMax()) );
989 Double_t sigmaYS = fClusterParam->GetErrorQParScaled( 0, padSize, (250.0 - TMath::Abs(cluster->GetZ())),
990 TMath::Abs(angley), TMath::Abs(cluster->GetMax()) );
991 Double_t sigmaZS = fClusterParam->GetErrorQParScaled( 1, padSize, (250.0 - TMath::Abs(cluster->GetZ())),
992 TMath::Abs(anglez), TMath::Abs(cluster->GetMax()) );
993 Float_t rmsYFactor = fClusterParam->GetShapeFactor( 0, padSize,(250.0 - TMath::Abs(cluster->GetZ())),
994 TMath::Abs(anglez), TMath::Abs(cluster->GetMax()),
995 TMath::Sqrt(cluster0->GetSigmaY2()), 0 );
996 Float_t rmsZFactor = fClusterParam->GetShapeFactor(0, padSize,(250.0 - TMath::Abs(cluster->GetZ())),
997 TMath::Abs(anglez), TMath::Abs(cluster->GetMax()),
998 TMath::Sqrt(cluster0->GetSigmaZ2()),0 );
999 sigmaYS = TMath::Sqrt(sigmaYS * sigmaYS + rmsYFactor * rmsYFactor / 12.);
1000 sigmaZS = TMath::Sqrt(sigmaZS * sigmaZS + rmsZFactor * rmsZFactor / 12. + rmsYFactor * rmsYFactor / 24.);
1003 fitY0.AddPoint(&x, cluster->GetY(), sigmaY0);
1004 fitZ0.AddPoint(&x, cluster->GetZ(), sigmaZ0);
1007 xxx[0] = ( (idelta+irow) % 2 == 0 ) ? 1 : 0;
1009 xxx[2] = ( (idelta+irow) % 2 == 0 ) ? x : 0;
1011 fitY2.AddPoint(xxx, cluster->GetY(), sigmaY0);
1012 fitY2Q.AddPoint(xxx, cluster->GetY(), sigmaYQ);
1013 fitY2S.AddPoint(xxx, cluster->GetY(), sigmaYS);
1014 fitZ2.AddPoint(xxx, cluster->GetZ(), sigmaZ0);
1015 fitZ2Q.AddPoint(xxx, cluster->GetZ(), sigmaZQ);
1016 fitZ2S.AddPoint(xxx, cluster->GetZ(), sigmaZS);
1018 } // neigbouhood-loop
1028 Float_t chi2Y0 = fitY0.GetChisquare() / (nclFound-3.);
1029 Float_t chi2Z0 = fitZ0.GetChisquare() / (nclFound-3.);
1030 Float_t chi2Y2 = fitY2.GetChisquare() / (nclFound-5.);
1031 Float_t chi2Z2 = fitZ2.GetChisquare() / (nclFound-5.);
1032 Float_t chi2Y2Q = fitY2Q.GetChisquare() / (nclFound-5.);
1033 Float_t chi2Z2Q = fitZ2Q.GetChisquare() / (nclFound-5.);
1034 Float_t chi2Y2S = fitY2S.GetChisquare() / (nclFound-5.);
1035 Float_t chi2Z2S = fitZ2S.GetChisquare() / (nclFound-5.);
1037 static TVectorD parY0(3);
1038 static TMatrixD matY0(3, 3);
1039 static TVectorD parZ0(3);
1040 static TMatrixD matZ0(3, 3);
1041 fitY0.GetParameters(parY0);
1042 fitY0.GetCovarianceMatrix(matY0);
1043 fitZ0.GetParameters(parZ0);
1044 fitZ0.GetCovarianceMatrix(matZ0);
1046 static TVectorD parY2(5);
1047 static TMatrixD matY2(5,5);
1048 static TVectorD parZ2(5);
1049 static TMatrixD matZ2(5,5);
1050 fitY2.GetParameters(parY2);
1051 fitY2.GetCovarianceMatrix(matY2);
1052 fitZ2.GetParameters(parZ2);
1053 fitZ2.GetCovarianceMatrix(matZ2);
1055 static TVectorD parY2Q(5);
1056 static TMatrixD matY2Q(5,5);
1057 static TVectorD parZ2Q(5);
1058 static TMatrixD matZ2Q(5,5);
1059 fitY2Q.GetParameters(parY2Q);
1060 fitY2Q.GetCovarianceMatrix(matY2Q);
1061 fitZ2Q.GetParameters(parZ2Q);
1062 fitZ2Q.GetCovarianceMatrix(matZ2Q);
1063 static TVectorD parY2S(5);
1064 static TMatrixD matY2S(5,5);
1065 static TVectorD parZ2S(5);
1066 static TMatrixD matZ2S(5,5);
1067 fitY2S.GetParameters(parY2S);
1068 fitY2S.GetCovarianceMatrix(matY2S);
1069 fitZ2S.GetParameters(parZ2S);
1070 fitZ2S.GetCovarianceMatrix(matZ2S);
1071 Float_t sigmaY0 = TMath::Sqrt(matY0(0,0));
1072 Float_t sigmaZ0 = TMath::Sqrt(matZ0(0,0));
1073 Float_t sigmaDY0 = TMath::Sqrt(matY0(1,1));
1074 Float_t sigmaDZ0 = TMath::Sqrt(matZ0(1,1));
1075 Float_t sigmaY2 = TMath::Sqrt(matY2(1,1));
1076 Float_t sigmaZ2 = TMath::Sqrt(matZ2(1,1));
1077 Float_t sigmaDY2 = TMath::Sqrt(matY2(3,3));
1078 Float_t sigmaDZ2 = TMath::Sqrt(matZ2(3,3));
1079 Float_t sigmaY2Q = TMath::Sqrt(matY2Q(1,1));
1080 Float_t sigmaZ2Q = TMath::Sqrt(matZ2Q(1,1));
1081 Float_t sigmaDY2Q = TMath::Sqrt(matY2Q(3,3));
1082 Float_t sigmaDZ2Q = TMath::Sqrt(matZ2Q(3,3));
1083 Float_t sigmaY2S = TMath::Sqrt(matY2S(1,1));
1084 Float_t sigmaZ2S = TMath::Sqrt(matZ2S(1,1));
1085 Float_t sigmaDY2S = TMath::Sqrt(matY2S(3,3));
1086 Float_t sigmaDZ2S = TMath::Sqrt(matZ2S(3,3));
1089 Float_t csigmaY0 = fClusterParam->GetError0Par(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),TMath::Abs(angley));
1090 Float_t csigmaZ0 = fClusterParam->GetError0Par(1,padSize,(250.0-TMath::Abs(cluster0->GetZ())),TMath::Abs(anglez));
1092 Float_t csigmaYQ = fClusterParam->GetErrorQPar(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1093 TMath::Abs(angley), TMath::Abs(cluster0->GetMax()));
1094 Float_t csigmaZQ = fClusterParam->GetErrorQPar(1,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1095 TMath::Abs(anglez),TMath::Abs(cluster0->GetMax()));
1096 Float_t csigmaYS = fClusterParam->GetErrorQParScaled(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1097 TMath::Abs(angley), TMath::Abs(cluster0->GetMax()));
1098 Float_t csigmaZS = fClusterParam->GetErrorQParScaled(1,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1099 TMath::Abs(anglez),TMath::Abs(cluster0->GetMax()));
1103 Float_t meanRMSY = 0;
1104 Float_t meanRMSZ = 0;
1106 for (Int_t idelta = -2; idelta <= 2; idelta++){
1107 // loop over neighbourhood
1108 if (idelta+irow < 0 || idelta+irow > 159) continue;
1109 // if (idelta+irow>159) continue;
1110 AliTPCclusterMI * cluster = track->GetClusterPointer(irow+idelta);
1111 if (!cluster) continue;
1112 meanRMSY += TMath::Sqrt(cluster->GetSigmaY2());
1113 meanRMSZ += TMath::Sqrt(cluster->GetSigmaZ2());
1119 Float_t rmsY = TMath::Sqrt(cluster0->GetSigmaY2());
1120 Float_t rmsZ = TMath::Sqrt(cluster0->GetSigmaZ2());
1121 Float_t rmsYT = fClusterParam->GetRMSQ(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1122 TMath::Abs(angley), TMath::Abs(cluster0->GetMax()));
1123 Float_t rmsZT = fClusterParam->GetRMSQ(1,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1124 TMath::Abs(anglez), TMath::Abs(cluster0->GetMax()));
1125 Float_t rmsYT0 = fClusterParam->GetRMS0(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1126 TMath::Abs(angley));
1127 Float_t rmsZT0 = fClusterParam->GetRMS0(1,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1128 TMath::Abs(anglez));
1129 Float_t rmsYSigma = fClusterParam->GetRMSSigma(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1130 TMath::Abs(anglez), TMath::Abs(cluster0->GetMax()));
1131 Float_t rmsZSigma = fClusterParam->GetRMSSigma(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1132 TMath::Abs(anglez), TMath::Abs(cluster0->GetMax()));
1133 Float_t rmsYFactor = fClusterParam->GetShapeFactor(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1134 TMath::Abs(anglez), TMath::Abs(cluster0->GetMax()),
1136 Float_t rmsZFactor = fClusterParam->GetShapeFactor(0,padSize,(250.0-TMath::Abs(cluster0->GetZ())),
1137 TMath::Abs(anglez), TMath::Abs(cluster0->GetMax()),
1141 TTreeSRedirector *cstream = GetDebugStreamer();
1143 (*cstream)<<"ResolCl"<< // valgrind 3 40,000 bytes in 1 blocks are possibly
1146 "CSigmaY0="<<csigmaY0<< // cluster errorY
1147 "CSigmaYQ="<<csigmaYQ<< // cluster errorY - q scaled
1148 "CSigmaYS="<<csigmaYS<< // cluster errorY - q scaled
1149 "CSigmaZ0="<<csigmaZ0<< //
1150 "CSigmaZQ="<<csigmaZQ<<
1151 "CSigmaZS="<<csigmaZS<<
1152 "shapeYF="<<rmsYFactor<<
1153 "shapeZF="<<rmsZFactor<<
1156 "rmsYM="<<meanRMSY<<
1157 "rmsZM="<<meanRMSZ<<
1162 "rmsYS="<<rmsYSigma<<
1163 "rmsZS="<<rmsZSigma<<
1164 "padSize="<<padSize<<
1168 "SigmaY0="<<sigmaY0<<
1169 "SigmaZ0="<<sigmaZ0<<
1175 (*cstream)<<"ResolTr"<<
1176 "padSize="<<padSize<<
1184 "chi2Y2Q="<<chi2Y2Q<<
1185 "chi2Z2Q="<<chi2Z2Q<<
1186 "chi2Y2S="<<chi2Y2S<<
1187 "chi2Z2S="<<chi2Z2S<<
1196 "SigmaY0="<<sigmaY0<<
1197 "SigmaZ0="<<sigmaZ0<<
1198 "SigmaDY0="<<sigmaDY0<<
1199 "SigmaDZ0="<<sigmaDZ0<<
1200 "SigmaY2="<<sigmaY2<<
1201 "SigmaZ2="<<sigmaZ2<<
1202 "SigmaDY2="<<sigmaDY2<<
1203 "SigmaDZ2="<<sigmaDZ2<<
1204 "SigmaY2Q="<<sigmaY2Q<<
1205 "SigmaZ2Q="<<sigmaZ2Q<<
1206 "SigmaDY2Q="<<sigmaDY2Q<<
1207 "SigmaDZ2Q="<<sigmaDZ2Q<<
1208 "SigmaY2S="<<sigmaY2S<<
1209 "SigmaZ2S="<<sigmaZ2S<<
1210 "SigmaDY2S="<<sigmaDY2S<<
1211 "SigmaDZ2S="<<sigmaDZ2S<<
1223 TH2D * AliTPCcalibTracks::MakeDiff(TH2D * hfit, TF2 * func){
1225 // creates a new histogram which contains the difference between
1226 // the histogram hfit and the function func
1228 TH2D * result = (TH2D*)hfit->Clone(); // valgrind 3 40,139 bytes in 11 blocks are still reachable
1229 result->SetTitle(Form("%s fit residuals",result->GetTitle()));
1230 result->SetName(Form("%s fit residuals",result->GetName()));
1231 TAxis *xaxis = hfit->GetXaxis();
1232 TAxis *yaxis = hfit->GetYaxis();
1234 for (Int_t biny = 0; biny <= yaxis->GetNbins(); biny++) {
1235 x[1] = yaxis->GetBinCenter(biny);
1236 for (Int_t binx = 0; binx <= xaxis->GetNbins(); binx++) {
1237 x[0] = xaxis->GetBinCenter(binx);
1238 Int_t bin = hfit->GetBin(binx, biny);
1239 Double_t val = hfit->GetBinContent(bin);
1240 // result->SetBinContent( bin, (val - func->Eval(x[0], x[1])) / func->Eval(x[0], x[1]) );
1241 result->SetBinContent( bin, (val / func->Eval(x[0], x[1])) - 1 );
1248 void AliTPCcalibTracks::SetStyle() const {
1250 // set style, can be called by all draw functions
1252 gROOT->SetStyle("Plain");
1253 gStyle->SetFillColor(10);
1254 gStyle->SetPadColor(10);
1255 gStyle->SetCanvasColor(10);
1256 gStyle->SetStatColor(10);
1257 gStyle->SetPalette(1,0);
1258 gStyle->SetNumberContours(60);
1262 void AliTPCcalibTracks::Draw(Option_t* opt){
1264 // draw-function of AliTPCcalibTracks
1265 // will draws some exemplaric pictures
1268 if (GetDebugLevel() > 6) Info("Draw", "Drawing an exemplaric picture.");
1272 TCanvas *c1 = new TCanvas();
1274 TVirtualPad *upperThird = c1->GetPad(1);
1275 TVirtualPad *middleThird = c1->GetPad(2);
1276 TVirtualPad *lowerThird = c1->GetPad(3);
1277 upperThird->Divide(2,0);
1278 TVirtualPad *upleft = upperThird->GetPad(1);
1279 TVirtualPad *upright = upperThird->GetPad(2);
1280 middleThird->Divide(2,0);
1281 TVirtualPad *middleLeft = middleThird->GetPad(1);
1282 TVirtualPad *middleRight = middleThird->GetPad(2);
1283 lowerThird->Divide(2,0);
1284 TVirtualPad *downLeft = lowerThird->GetPad(1);
1285 TVirtualPad *downRight = lowerThird->GetPad(2);
1289 min = fDeltaY->GetBinCenter(fDeltaY->GetMaximumBin())-20;
1290 max = fDeltaY->GetBinCenter(fDeltaY->GetMaximumBin())+20;
1291 fDeltaY->SetAxisRange(min, max);
1292 fDeltaY->Fit("gaus","q","",min, max); // valgrind 3 7 block possibly lost 2,400 bytes in 1 blocks are still reachable
1296 max = fDeltaZ->GetBinCenter(fDeltaZ->GetMaximumBin())+20;
1297 min = fDeltaZ->GetBinCenter(fDeltaZ->GetMaximumBin())-20;
1298 fDeltaZ->SetAxisRange(min, max);
1299 fDeltaZ->Fit("gaus","q","",min, max);
1306 fRejectedTracksHisto->Draw(opt);
1307 TPaveText *pt = new TPaveText(0.6,0.6, 0.8,0.8, "NDC");
1308 TText *t1 = pt->AddText("1: kEdgeThetaCutNoise");
1309 TText *t2 = pt->AddText("2: kMinClusters");
1310 TText *t3 = pt->AddText("3: kMinRatio");
1311 TText *t4 = pt->AddText("4: kMax1pt");
1312 t1 = t1; t2 = t2; t3 = t3; t4 = t4; // avoid compiler warnings
1313 pt->SetToolTipText("Legend for failed cuts");
1317 fHclusterPerPadrowRaw->Draw(opt);
1320 fHclusterPerPadrow->Draw(opt);
1324 void AliTPCcalibTracks::MakeReport(Int_t stat, char* pathName){
1326 // all functions are called, that produce pictures
1327 // the histograms are written to the directory 'pathName'
1328 // 'stat' is a threshhold: only histograms with more than 'stat' entries are wirtten to file
1329 // 'stat' is also the number of minEntries for MakeResPlotsQTree
1332 if (GetDebugLevel() > 0) Info("MakeReport","Writing plots and trees to '%s'.", pathName);
1333 MakeAmpPlots(stat, pathName);
1334 MakeDeltaPlots(pathName);
1335 FitResolutionNew(pathName);
1336 FitRMSNew(pathName);
1337 MakeChargeVsDriftLengthPlots(pathName);
1338 // MakeResPlotsQ(1, 1);
1339 MakeResPlotsQTree(stat, pathName);
1343 void AliTPCcalibTracks::MakeAmpPlots(Int_t stat, char* pathName){
1345 // creates several plots:
1346 // fArrayAmp.ps, fArrayAmpRow.ps and DeltaYZ.ps
1347 // fArrayAmp.ps: one histogram per sector, the histogram shows the charge per cluster
1348 // fArrayAmpRow.ps: one histogram per sector, mean max. amplitude vs. pad row with landau fit
1349 // DeltaYZ.ps: DeltaY and DeltaZ histogram with gaus fit
1350 // Empty histograms (sectors without data) are not written to file
1351 // the ps-files are written to the directory 'pathName', that is created if it does not exist
1352 // 'stat': only histograms with more than 'stat' entries are written to file.
1356 gSystem->MakeDirectory(pathName);
1357 gSystem->ChangeDirectory(pathName);
1359 TCanvas* c1 = new TCanvas(); // valgrind 3 ??? 634 bytes in 28 blocks are still reachable
1361 // histograms with accumulated amplitude for all IROCs and OROCs
1362 TH1F *allAmpHisIROC = ((TH1F*)(fArrayAmp->At(0))->Clone());
1363 allAmpHisIROC->SetName("Amp all IROCs");
1364 allAmpHisIROC->SetTitle("Amp all IROCs");
1365 TH1F *allAmpHisOROC = ((TH1F*)(fArrayAmp->At(36))->Clone());
1366 allAmpHisOROC->SetName("Amp all OROCs");
1367 allAmpHisOROC->SetTitle("Amp all OROCs");
1369 ps = new TPostScript("fArrayAmp.ps", 112);
1370 if (GetDebugLevel() > -1) cout << "creating fArrayAmp.ps..." << endl;
1371 for (Int_t i = 0; i < fArrayAmp->GetEntriesFast(); i++){
1372 if ( ((TH1F*)fArrayAmp->At(i))->GetEntries() < stat ) continue;
1374 ((TH1F*)fArrayAmp->At(i))->Draw();
1375 c1->Update(); // valgrind 3
1376 if (i > 0 && i < 36) {
1377 allAmpHisIROC->Add(((TH1F*)fArrayAmp->At(i)));
1378 allAmpHisOROC->Add(((TH1F*)fArrayAmp->At(i+36)));
1382 allAmpHisIROC->Draw();
1383 c1->Update(); // valgrind
1385 allAmpHisOROC->Draw();
1393 ps = new TPostScript("fArrayAmpRow.ps", 112);
1394 if (GetDebugLevel() > -1) cout << "creating fArrayAmpRow.ps..." << endl;
1395 for (Int_t i = 0; i < fArrayAmpRow->GetEntriesFast(); i++){
1396 his = (TH1F*)fArrayAmpRow->At(i);
1397 if (his->GetEntries() < stat) continue;
1399 min = TMath::Max( his->GetBinCenter(his->GetMaximumBin() )-100., 0.);
1400 max = his->GetBinCenter(5*his->GetMaximumBin()) + 100;
1401 his->SetAxisRange(min, max);
1402 his->Fit("pol3", "q", "", min, max);
1403 // his->Draw("error"); // don't use this line when you don't want to have empty pages in the ps-file
1409 gSystem->ChangeDirectory("..");
1413 void AliTPCcalibTracks::MakeDeltaPlots(char* pathName){
1415 // creates several plots:
1416 // DeltaYZ.ps: DeltaY and DeltaZ histogram with gaus fit
1417 // the ps-files are written to the directory 'pathName', that is created if it does not exist
1421 gSystem->MakeDirectory(pathName);
1422 gSystem->ChangeDirectory(pathName);
1424 TCanvas* c1 = new TCanvas(); // valgrind 3 ??? 634 bytes in 28 blocks are still reachable
1429 ps = new TPostScript("DeltaYZ.ps", 112);
1430 if (GetDebugLevel() > -1) cout << "creating DeltaYZ.ps..." << endl;
1431 min = fDeltaY->GetBinCenter(fDeltaY->GetMaximumBin())-20;
1432 max = fDeltaY->GetBinCenter(fDeltaY->GetMaximumBin())+20;
1433 fDeltaY->SetAxisRange(min, max);
1435 fDeltaY->Fit("gaus","q","",min, max); // valgrind 3 7 block possibly lost 2,400 bytes in 1 blocks are still reachable
1438 max = fDeltaZ->GetBinCenter(fDeltaZ->GetMaximumBin())+20;
1439 min = fDeltaZ->GetBinCenter(fDeltaZ->GetMaximumBin())-20;
1440 fDeltaZ->SetAxisRange(min, max);
1441 fDeltaZ->Fit("gaus","q","",min, max);
1446 gSystem->ChangeDirectory("..");
1450 void AliTPCcalibTracks::MakeChargeVsDriftLengthPlotsOld(char* pathName){
1452 // creates charge vs. driftlength plots, one TProfile for each ROC
1453 // is not correct like this, should be one TProfile for each sector and padsize
1457 gSystem->MakeDirectory(pathName);
1458 gSystem->ChangeDirectory(pathName);
1460 TCanvas* c1 = new TCanvas(); // valgrind 3 ??? 634 bytes in 28 blocks are still reachable
1462 ps = new TPostScript("chargeVsDriftlengthOld.ps", 112);
1463 if (GetDebugLevel() > -1) cout << "creating chargeVsDriftlength.ps..." << endl;
1464 TProfile *chargeVsDriftlengthAllIROCs = ((TProfile*)fArrayChargeVsDriftlength->At(0)->Clone());
1465 TProfile *chargeVsDriftlengthAllOROCs = ((TProfile*)fArrayChargeVsDriftlength->At(36)->Clone());
1466 chargeVsDriftlengthAllIROCs->SetName("allAmpHisIROC");
1467 chargeVsDriftlengthAllIROCs->SetTitle("charge vs. driftlength, all IROCs");
1468 chargeVsDriftlengthAllOROCs->SetName("allAmpHisOROC");
1469 chargeVsDriftlengthAllOROCs->SetTitle("charge vs. driftlength, all OROCs");
1471 for (Int_t i = 0; i < fArrayChargeVsDriftlength->GetEntriesFast(); i++) {
1472 ((TProfile*)fArrayChargeVsDriftlength->At(i))->Draw();
1474 if (i > 0 && i < 36) {
1475 chargeVsDriftlengthAllIROCs->Add(((TProfile*)fArrayChargeVsDriftlength->At(i)));
1476 chargeVsDriftlengthAllOROCs->Add(((TProfile*)fArrayChargeVsDriftlength->At(i+36)));
1480 chargeVsDriftlengthAllIROCs->Draw();
1481 c1->Update(); // valgrind
1483 chargeVsDriftlengthAllOROCs->Draw();
1488 gSystem->ChangeDirectory("..");
1492 void AliTPCcalibTracks::MakeChargeVsDriftLengthPlots(char* pathName){
1494 // creates charge vs. driftlength plots, one TProfile for each ROC
1495 // under development....
1499 gSystem->MakeDirectory(pathName);
1500 gSystem->ChangeDirectory(pathName);
1502 TCanvas* c1 = new TCanvas("c1", "c1", 700,(Int_t)(TMath::Sqrt(2)*700)); // valgrind 3 ??? 634 bytes in 28 blocks are still reachable
1503 // TCanvas c1("c1", "c1", 500,(sqrt(2)*500))
1506 ps = new TPostScript("chargeVsDriftlength.ps", 111);
1507 if (GetDebugLevel() > -1) cout << "creating chargeVsDriftlengthNew.ps..." << endl;
1509 TProfile *chargeVsDriftlengthAllShortPads = ((TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(0,0)->Clone());
1510 TProfile *chargeVsDriftlengthAllMediumPads = ((TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(0,1)->Clone());
1511 TProfile *chargeVsDriftlengthAllLongPads = ((TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(0,2)->Clone());
1512 chargeVsDriftlengthAllShortPads->SetName("allAmpHisShortPads");
1513 chargeVsDriftlengthAllShortPads->SetTitle("charge vs. driftlength, all sectors, short pads");
1514 chargeVsDriftlengthAllMediumPads->SetName("allAmpHisMediumPads");
1515 chargeVsDriftlengthAllMediumPads->SetTitle("charge vs. driftlength, all sectors, medium pads");
1516 chargeVsDriftlengthAllLongPads->SetName("allAmpHisLongPads");
1517 chargeVsDriftlengthAllLongPads->SetTitle("charge vs. driftlength, all sectors, long pads");
1519 for (Int_t i = 0; i < 36; i++) {
1520 c1->cd(1)->SetGridx();
1521 c1->cd(1)->SetGridy();
1522 ((TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(i,0))->Draw();
1523 c1->cd(2)->SetGridx();
1524 c1->cd(2)->SetGridy();
1525 ((TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(i,1))->Draw();
1526 c1->cd(3)->SetGridx();
1527 c1->cd(3)->SetGridy();
1528 ((TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(i,2))->Draw();
1530 chargeVsDriftlengthAllShortPads->Add( (TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(0,0));
1531 chargeVsDriftlengthAllMediumPads->Add((TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(0,1));
1532 chargeVsDriftlengthAllLongPads->Add( (TProfile*)fcalPadRegionChargeVsDriftlength->GetObject(0,2));
1535 c1->cd(1)->SetGridx();
1536 c1->cd(1)->SetGridy();
1537 chargeVsDriftlengthAllShortPads->Draw();
1538 c1->cd(2)->SetGridx();
1539 c1->cd(2)->SetGridy();
1540 chargeVsDriftlengthAllMediumPads->Draw();
1541 c1->cd(3)->SetGridx();
1542 c1->cd(3)->SetGridy();
1543 chargeVsDriftlengthAllLongPads->Draw();
1544 c1->Update(); // valgrind
1549 gSystem->ChangeDirectory("..");
1554 void AliTPCcalibTracks::FitResolutionNew(char* pathName){
1556 // calculates different resulution fits in Y and Z direction
1557 // the histograms are written to 'ResolutionYZ.ps'
1558 // writes calculated resolution to 'resol.txt'
1559 // all files are stored in the directory pathName
1563 gSystem->MakeDirectory(pathName);
1564 gSystem->ChangeDirectory(pathName);
1568 if (GetDebugLevel() > -1) cout << "creating ResolutionYZ.ps..." << endl;
1569 TPostScript *ps = new TPostScript("ResolutionYZ.ps", 112);
1570 TF2 *fres = new TF2("fres","TMath::Sqrt([0]*[0]+[1]*[1]*x+[2]*[2]*y*y)",0,250,0,1);
1571 fres->SetParameter(0,0.02);
1572 fres->SetParameter(1,0.0054);
1573 fres->SetParameter(2,0.13);
1575 TH1::AddDirectory(kTRUE); // TH3F::FitSlicesZ() writes histograms into the current directory
1577 // create histogramw for Y-resolution
1578 TH3F * hisResY0 = (TH3F*)fResolY->At(0);
1579 hisResY0->FitSlicesZ();
1580 TH2D * hisResY02 = (TH2D*)gDirectory->Get("Resol Y0_2");
1581 TH3F * hisResY1 = (TH3F*)fResolY->At(1);
1582 hisResY1->FitSlicesZ();
1583 TH2D * hisResY12 = (TH2D*)gDirectory->Get("Resol Y1_2");
1584 TH3F * hisResY2 = (TH3F*)fResolY->At(2);
1585 hisResY2->FitSlicesZ();
1586 TH2D * hisResY22 = (TH2D*)gDirectory->Get("Resol Y2_2");
1590 hisResY02->Fit(fres, "q"); // valgrind 132,072 bytes in 6 blocks are indirectly lost
1591 hisResY02->Draw("surf1");
1593 MakeDiff(hisResY02,fres)->Draw("surf1");
1595 // c.SaveAs("ResolutionYPad0.eps");
1598 hisResY12->Fit(fres, "q");
1599 hisResY12->Draw("surf1");
1601 MakeDiff(hisResY12,fres)->Draw("surf1");
1603 // c.SaveAs("ResolutionYPad1.eps");
1606 hisResY22->Fit(fres, "q");
1607 hisResY22->Draw("surf1");
1609 MakeDiff(hisResY22,fres)->Draw("surf1");
1611 // c.SaveAs("ResolutionYPad2.eps");
1613 // create histogramw for Z-resolution
1614 TH3F * hisResZ0 = (TH3F*)fResolZ->At(0);
1615 hisResZ0->FitSlicesZ();
1616 TH2D * hisResZ02 = (TH2D*)gDirectory->Get("Resol Z0_2");
1617 TH3F * hisResZ1 = (TH3F*)fResolZ->At(1);
1618 hisResZ1->FitSlicesZ();
1619 TH2D * hisResZ12 = (TH2D*)gDirectory->Get("Resol Z1_2");
1620 TH3F * hisResZ2 = (TH3F*)fResolZ->At(2);
1621 hisResZ2->FitSlicesZ();
1622 TH2D * hisResZ22 = (TH2D*)gDirectory->Get("Resol Z2_2");
1626 hisResZ02->Fit(fres, "q");
1627 hisResZ02->Draw("surf1");
1629 MakeDiff(hisResZ02,fres)->Draw("surf1");
1631 // c.SaveAs("ResolutionZPad0.eps");
1634 hisResZ12->Fit(fres, "q");
1635 hisResZ12->Draw("surf1");
1637 MakeDiff(hisResZ12,fres)->Draw("surf1");
1639 // c.SaveAs("ResolutionZPad1.eps");
1642 hisResZ22->Fit(fres, "q");
1643 hisResZ22->Draw("surf1");
1645 MakeDiff(hisResZ22,fres)->Draw("surf1");
1647 // c.SaveAs("ResolutionZPad2.eps");
1651 // write calculated resoltuions to 'resol.txt'
1652 ofstream fresol("resol.txt");
1653 fresol<<"Pad 0.75 cm"<<"\n";
1654 hisResY02->Fit(fres, "q"); // valgrind
1655 fresol<<"Y\t"<<fres->GetParameter(0)<<"\t"<<fres->GetParameter(1)<<"\t"<<fres->GetParameter(2)<<"\n";
1656 hisResZ02->Fit(fres, "q");
1657 fresol<<"Z\t"<<fres->GetParameter(0)<<"\t"<<fres->GetParameter(1)<<"\t"<<fres->GetParameter(2)<<"\n";
1659 fresol<<"Pad 1.00 cm"<<1<<"\n";
1660 hisResY12->Fit(fres, "q"); // valgrind
1661 fresol<<"Y\t"<<fres->GetParameter(0)<<"\t"<<fres->GetParameter(1)<<"\t"<<fres->GetParameter(2)<<"\n";
1662 hisResZ12->Fit(fres, "q");
1663 fresol<<"Z\t"<<fres->GetParameter(0)<<"\t"<<fres->GetParameter(1)<<"\t"<<fres->GetParameter(2)<<"\n";
1665 fresol<<"Pad 1.50 cm"<<0<<"\n";
1666 hisResY22->Fit(fres, "q");
1667 fresol<<"Y\t"<<fres->GetParameter(0)<<"\t"<<fres->GetParameter(1)<<"\t"<<fres->GetParameter(2)<<"\n";
1668 hisResZ22->Fit(fres, "q");
1669 fresol<<"Z\t"<<fres->GetParameter(0)<<"\t"<<fres->GetParameter(1)<<"\t"<<fres->GetParameter(2)<<"\n";
1671 TH1::AddDirectory(kFALSE);
1672 gSystem->ChangeDirectory("..");
1677 void AliTPCcalibTracks::FitRMSNew(char* pathName){
1679 // calculates different resulution-rms fits in Y and Z direction
1680 // the histograms are written to 'RMS_YZ.ps'
1681 // writes calculated resolution rms to 'rms.txt'
1682 // all files are stored in the directory pathName
1686 gSystem->MakeDirectory(pathName);
1687 gSystem->ChangeDirectory(pathName);
1689 TCanvas c; // valgrind 3 42,120 bytes in 405 blocks are still reachable 23,816 bytes in 229 blocks are still reachable
1691 if (GetDebugLevel() > -1) cout << "creating RMS_YZ.ps..." << endl;
1692 TPostScript *ps = new TPostScript("RMS_YZ.ps", 112);
1693 TF2 *frms = new TF2("fres","TMath::Sqrt([0]*[0]+[1]*[1]*x+[2]*[2]*y*y)",0,250,0,1);
1694 frms->SetParameter(0,0.02);
1695 frms->SetParameter(1,0.0054);
1696 frms->SetParameter(2,0.13);
1698 TH1::AddDirectory(kTRUE); // TH3F::FitSlicesZ() writes histograms into the current directory
1700 // create histogramw for Y-RMS
1701 TH3F * hisResY0 = (TH3F*)fRMSY->At(0);
1702 hisResY0->FitSlicesZ();
1703 TH2D * hisResY02 = (TH2D*)gDirectory->Get("RMS Y0_1");
1704 TH3F * hisResY1 = (TH3F*)fRMSY->At(1);
1705 hisResY1->FitSlicesZ();
1706 TH2D * hisResY12 = (TH2D*)gDirectory->Get("RMS Y1_1");
1707 TH3F * hisResY2 = (TH3F*)fRMSY->At(2);
1708 hisResY2->FitSlicesZ();
1709 TH2D * hisResY22 = (TH2D*)gDirectory->Get("RMS Y2_1");
1713 hisResY02->Fit(frms, "qn0");
1714 hisResY02->Draw("surf1");
1716 MakeDiff(hisResY02,frms)->Draw("surf1");
1718 // c.SaveAs("RMSYPad0.eps");
1721 hisResY12->Fit(frms, "qn0"); // valgrind several blocks possibly lost
1722 hisResY12->Draw("surf1");
1724 MakeDiff(hisResY12,frms)->Draw("surf1");
1726 // c.SaveAs("RMSYPad1.eps");
1729 hisResY22->Fit(frms, "qn0");
1730 hisResY22->Draw("surf1");
1732 MakeDiff(hisResY22,frms)->Draw("surf1");
1734 // c.SaveAs("RMSYPad2.eps");
1736 // create histogramw for Z-RMS
1737 TH3F * hisResZ0 = (TH3F*)fRMSZ->At(0);
1738 hisResZ0->FitSlicesZ();
1739 TH2D * hisResZ02 = (TH2D*)gDirectory->Get("RMS Z0_1");
1740 TH3F * hisResZ1 = (TH3F*)fRMSZ->At(1);
1741 hisResZ1->FitSlicesZ();
1742 TH2D * hisResZ12 = (TH2D*)gDirectory->Get("RMS Z1_1");
1743 TH3F * hisResZ2 = (TH3F*)fRMSZ->At(2);
1744 hisResZ2->FitSlicesZ();
1745 TH2D * hisResZ22 = (TH2D*)gDirectory->Get("RMS Z2_1");
1749 hisResZ02->Fit(frms, "qn0"); // valgrind
1750 hisResZ02->Draw("surf1");
1752 MakeDiff(hisResZ02,frms)->Draw("surf1");
1754 // c.SaveAs("RMSZPad0.eps");
1757 hisResZ12->Fit(frms, "qn0");
1758 hisResZ12->Draw("surf1");
1760 MakeDiff(hisResZ12,frms)->Draw("surf1");
1762 // c.SaveAs("RMSZPad1.eps");
1765 hisResZ22->Fit(frms, "qn0"); // valgrind 1 block possibly lost
1766 hisResZ22->Draw("surf1");
1768 MakeDiff(hisResZ22,frms)->Draw("surf1");
1770 // c.SaveAs("RMSZPad2.eps");
1772 // write calculated resoltuion rms to 'rms.txt'
1773 ofstream filerms("rms.txt");
1774 filerms<<"Pad 0.75 cm"<<"\n";
1775 hisResY02->Fit(frms, "qn0"); // valgrind 23 blocks indirectly lost
1776 filerms<<"Y\t"<<frms->GetParameter(0)<<"\t"<<frms->GetParameter(1)<<"\t"<<frms->GetParameter(2)<<"\n";
1777 hisResZ02->Fit(frms, "qn0"); // valgrind 23 blocks indirectly lost
1778 filerms<<"Z\t"<<frms->GetParameter(0)<<"\t"<<frms->GetParameter(1)<<"\t"<<frms->GetParameter(2)<<"\n";
1780 filerms<<"Pad 1.00 cm"<<1<<"\n";
1781 hisResY12->Fit(frms, "qn0"); // valgrind 3,256 bytes in 22 blocks are indirectly lost
1782 filerms<<"Y\t"<<frms->GetParameter(0)<<"\t"<<frms->GetParameter(1)<<"\t"<<frms->GetParameter(2)<<"\n";
1783 hisResZ12->Fit(frms, "qn0"); // valgrind 66,036 bytes in 3 blocks are still reachable
1784 filerms<<"Z\t"<<frms->GetParameter(0)<<"\t"<<frms->GetParameter(1)<<"\t"<<frms->GetParameter(2)<<"\n";
1786 filerms<<"Pad 1.50 cm"<<0<<"\n";
1787 hisResY22->Fit(frms, "qn0"); // valgrind 40,139 bytes in 11 blocks are still reachable 330,180 bytes in 15 blocks are possibly lost
1788 filerms<<"Y\t"<<frms->GetParameter(0)<<"\t"<<frms->GetParameter(1)<<"\t"<<frms->GetParameter(2)<<"\n";
1789 hisResZ22->Fit(frms, "qn0");
1790 filerms<<"Z\t"<<frms->GetParameter(0)<<"\t"<<frms->GetParameter(1)<<"\t"<<frms->GetParameter(2)<<"\n";
1792 TH1::AddDirectory(kFALSE);
1793 gSystem->ChangeDirectory("..");
1800 void AliTPCcalibTracks::MakeResPlotsQTree(Int_t minEntries, char* pathName){
1802 // Make tree with resolution parameters
1803 // the result is written to 'resol.root' in directory 'pathname'
1804 // file information are available in fileInfo
1805 // available variables in the tree 'Resol':
1806 // Entries: number of entries for this resolution point
1807 // nbins: number of bins that were accumulated
1808 // Dim: direction, Dim==0: y-direction, Dim==1: z-direction
1809 // Pad: padSize; short, medium and long
1810 // Length: pad length, 0.75, 1, 1.5
1811 // QMean: mean charge of current charge bin and its neighbours, Qmean<0: integrated spectra
1812 // Zc: center of middle bin in drift direction
1813 // Zm: mean dirftlength for accumulated Delta-Histograms
1814 // Zs: width of driftlength bin
1815 // AngleC: center of middle bin in Angle-Direction
1816 // AngleM: mean angle for accumulated Delta-Histograms
1817 // AngleS: width of Angle-bin
1818 // Resol: sigma for gaus fit through Delta-Histograms
1819 // Sigma: error of sigma for gaus fit through Delta Histograms
1820 // MeanR: mean of the Delta-Histogram
1821 // SigmaR: rms of the Delta-Histogram
1822 // RMSm: mean of the gaus fit through RMS-Histogram
1823 // RMS: sigma of the gaus fit through RMS-Histogram
1824 // RMSe0: error of mean of gaus fit in RMS-Histogram
1825 // RMSe1: error of sigma of gaus fit in RMS-Histogram
1828 if (GetDebugLevel() > -1) cout << " ***** this is MakeResPlotsQTree *****" << endl;
1829 if (GetDebugLevel() > -1) cout << " relax, the calculation will take a while..." << endl;
1831 gSystem->MakeDirectory(pathName);
1832 gSystem->ChangeDirectory(pathName);
1833 TString kFileName = "resol.root";
1834 TTreeSRedirector fTreeResol(kFileName.Data());
1836 TH3F *resArray[2][3][11];
1837 TH3F *rmsArray[2][3][11];
1839 // load histograms from fArrayQDY and fArrayQDZ
1840 // into resArray and rmsArray
1841 // that is all we need here
1842 for (Int_t idim = 0; idim < 2; idim++){
1843 for (Int_t ipad = 0; ipad < 3; ipad++){
1844 for (Int_t iq = 0; iq <= 10; iq++){
1845 rmsArray[idim][ipad][iq]=0;
1846 resArray[idim][ipad][iq]=0;
1847 Int_t bin = GetBin(iq,ipad);
1849 if (idim == 0) hresl = (TH3F*)fArrayQDY->At(bin);
1850 if (idim == 1) hresl = (TH3F*)fArrayQDZ->At(bin);
1851 if (!hresl) continue;
1852 resArray[idim][ipad][iq] = (TH3F*) hresl->Clone();
1853 resArray[idim][ipad][iq]->SetDirectory(0);
1854 TH3F * hreslRMS = 0;
1855 if (idim == 0) hreslRMS = (TH3F*)fArrayQRMSY->At(bin);
1856 if (idim == 1) hreslRMS = (TH3F*)fArrayQRMSZ->At(bin);
1857 if (!hreslRMS) continue;
1858 rmsArray[idim][ipad][iq] = (TH3F*) hreslRMS->Clone();
1859 rmsArray[idim][ipad][iq]->SetDirectory(0);
1863 if (GetDebugLevel() > -1) cout << "Histograms loaded, starting to proces..." << endl;
1865 //--------------------------------------------------------------------------------------------
1869 Double_t zMean, angleMean, zCenter, angleCenter;
1870 Double_t zSigma, angleSigma;
1871 TH1D *projectionRes = new TH1D("projectionRes", "projectionRes", 50, -1, 1);
1872 TH1D *projectionRms = new TH1D("projectionRms", "projectionRms", 50, -1, 1);
1873 TF1 *fitFunction = new TF1("fitFunction", "gaus");
1874 Float_t entriesQ = 0;
1875 Int_t loopCounter = 1;
1877 for (Int_t idim = 0; idim < 2; idim++){
1878 // Loop y-z corrdinate
1879 for (Int_t ipad = 0; ipad < 3; ipad++){
1881 for (Int_t iq = -1; iq < 10; iq++){
1883 if (GetDebugLevel() > -1)
1884 cout << "Loop-counter, this is loop " << loopCounter << " of 66, ("
1885 << (Int_t)((loopCounter)/66.*100) << "% done), "
1886 << "idim = " << idim << ", ipad = " << ipad << ", iq = " << iq << " \r" << std::flush;
1895 // integrated spectra
1896 for (Int_t iql = 0; iql < 10; iql++){
1897 Int_t bin = GetBin(iql,ipad);
1898 TH3F *hresl = resArray[idim][ipad][iql];
1899 TH3F *hrmsl = rmsArray[idim][ipad][iql];
1900 if (!hresl) continue;
1901 if (!hrmsl) continue;
1902 entriesQ += hresl->GetEntries();
1903 qMean += hresl->GetEntries() * GetQ(bin);
1905 hres = (TH3F*)hresl->Clone();
1906 hrms = (TH3F*)hrmsl->Clone();
1914 qMean *= -1.; // integral mean charge
1917 // loop over neighboured Q-bins
1918 // accumulate entries from neighboured Q-bins
1919 for (Int_t iql = iq - 1; iql <= iq + 1; iql++){
1920 if (iql < 0) continue;
1921 Int_t bin = GetBin(iql,ipad);
1922 TH3F * hresl = resArray[idim][ipad][iql];
1923 TH3F * hrmsl = rmsArray[idim][ipad][iql];
1924 if (!hresl) continue;
1925 if (!hrmsl) continue;
1926 entriesQ += hresl->GetEntries();
1927 qMean += hresl->GetEntries() * GetQ(bin);
1929 hres = (TH3F*) hresl->Clone();
1930 hrms = (TH3F*) hrmsl->Clone();
1940 TAxis *xAxisDriftLength = hres->GetXaxis(); // driftlength / z - axis
1941 TAxis *yAxisAngle = hres->GetYaxis(); // angle axis
1942 TAxis *zAxisDelta = hres->GetZaxis(); // delta axis
1943 TAxis *zAxisRms = hrms->GetZaxis(); // rms axis
1945 // loop over all angle bins
1946 for (Int_t ibinyAngle = 1; ibinyAngle <= yAxisAngle->GetNbins(); ibinyAngle++) {
1947 angleCenter = yAxisAngle->GetBinCenter(ibinyAngle);
1948 // loop over all driftlength bins
1949 for (Int_t ibinxDL = 1; ibinxDL <= xAxisDriftLength->GetNbins(); ibinxDL++) {
1950 zCenter = xAxisDriftLength->GetBinCenter(ibinxDL);
1951 zSigma = xAxisDriftLength->GetBinWidth(ibinxDL);
1952 angleSigma = yAxisAngle->GetBinWidth(ibinyAngle);
1953 zMean = zCenter; // changens, when more statistic is accumulated
1954 angleMean = angleCenter; // changens, when more statistic is accumulated
1956 // create 2 1D-Histograms, projectionRes and projectionRms
1957 // these histograms are delta histograms for given direction, padSize, chargeBin,
1958 // angleBin and driftLengthBin
1959 // later on they will be fitted with a gausian, its sigma is the resoltuion...
1960 sprintf(name,"%s, zCenter: %f, angleCenter: %f", hres->GetName(), zCenter, angleCenter);
1961 // TH1D * projectionRes = new TH1D(name, name, zAxisDelta->GetNbins(), zAxisDelta->GetXmin(), zAxisDelta->GetXmax());
1962 projectionRes->SetNameTitle(name, name);
1963 sprintf(name,"%s, zCenter: %f, angleCenter: %f", hrms->GetName(),zCenter,angleCenter);
1964 // TH1D * projectionRms = new TH1D(name, name, zAxisDelta->GetNbins(), zAxisRms->GetXmin(), zAxisRms->GetXmax());
1965 projectionRms->SetNameTitle(name, name);
1967 projectionRes->Reset();
1968 projectionRes->SetBins(zAxisDelta->GetNbins(), zAxisDelta->GetXmin(), zAxisDelta->GetXmax());
1969 projectionRms->Reset();
1970 projectionRms->SetBins(zAxisRms->GetNbins(), zAxisRms->GetXmin(), zAxisRms->GetXmax());
1971 projectionRes->SetDirectory(0);
1972 projectionRms->SetDirectory(0);
1974 Double_t entries = 0;
1975 Int_t nbins = 0; // counts, how many bins were accumulated
1980 // fill projectionRes and projectionRms for given dim, ipad and iq,
1981 // as well as for given angleBin and driftlengthBin
1982 // if this gives not enough statistic, include neighbourhood
1983 // (angle and driftlength) successifely
1984 for (Int_t dbin = 0; dbin <= 8; dbin++){ // delta-bins around centered angleBin and driftlengthBin
1985 for (Int_t dbiny2 = -1; dbiny2 <= 1; dbiny2++) { // delta-bins in angle direction
1986 for (Int_t dbinx2 = -3; dbinx2 <= 3; dbinx2++){ // delta-bins in driftlength direction
1987 if (TMath::Abs(dbinx2) + TMath::Abs(dbiny2) != dbin) continue; // add each bin only one time !
1988 Int_t binx2 = ibinxDL + dbinx2; // position variable in x (driftlength) direction
1989 Int_t biny2 = ibinyAngle + dbiny2; // position variable in y (angle) direction
1990 if (binx2 < 1 || biny2 < 1) continue; // don't go out of the histogram!
1991 if (binx2 >= xAxisDriftLength->GetNbins()) continue; // don't go out of the histogram!
1992 if (biny2 >= yAxisAngle->GetNbins()) continue; // don't go out of the histogram!
1993 nbins++; // count the number of accumulated bins
1994 // Fill resolution histo
1995 for (Int_t ibin3 = 1; ibin3 < zAxisDelta->GetNbins(); ibin3++) {
1996 // Int_t content = (Int_t)hres->GetBinContent(binx2, biny2, ibin3); // unused variable
1997 projectionRes->Fill(zAxisDelta->GetBinCenter(ibin3), hres->GetBinContent(binx2, biny2, ibin3));
1998 entries += hres->GetBinContent(binx2, biny2, ibin3);
1999 zMean += hres->GetBinContent(binx2, biny2, ibin3) * xAxisDriftLength->GetBinCenter(binx2);
2000 angleMean += hres->GetBinContent(binx2, biny2, ibin3) * yAxisAngle->GetBinCenter(biny2);
2003 for (Int_t ibin3 = 1; ibin3 < zAxisRms->GetNbins(); ibin3++) {
2004 projectionRms->Fill(zAxisRms->GetBinCenter(ibin3), hrms->GetBinContent(binx2, biny2, ibin3));
2007 if (entries > minEntries) break; // enough statistic accumulated
2009 if (entries > minEntries) break; // enough statistic accumulated
2011 if ( entries< minEntries) continue; // when it was absolutly impossible to get enough statistic, don't write this point into the resolution tree
2013 angleMean /= entries;
2015 if (entries > minEntries) {
2016 // when enough statistic is accumulated
2017 // fit Delta histograms with a gausian
2018 // of the gausian is the resolution (resol), its fit error is sigma
2019 // store also mean and RMS of the histogram
2020 Float_t xmin = projectionRes->GetMean() - 2. * projectionRes->GetRMS() - 0.2;
2021 Float_t xmax = projectionRes->GetMean() + 2. * projectionRes->GetRMS() + 0.2;
2023 // projectionRes->Fit("gaus", "q0", "", xmin, xmax);
2024 // Float_t resol = projectionRes->GetFunction("gaus")->GetParameter(2);
2025 // Float_t sigma = projectionRes->GetFunction("gaus")->GetParError(2);
2026 fitFunction->SetMaximum(xmax);
2027 fitFunction->SetMinimum(xmin);
2028 projectionRes->Fit("fitFunction", "qN0", "", xmin, xmax);
2029 Float_t resol = fitFunction->GetParameter(2);
2030 Float_t sigma = fitFunction->GetParError(2);
2032 Float_t meanR = projectionRes->GetMean();
2033 Float_t sigmaR = projectionRes->GetRMS();
2034 // fit also RMS histograms with a gausian
2035 // store mean and sigma of the gausian in rmsMean and rmsSigma
2036 // store also the fit errors in errorRMS and errorSigma
2037 xmin = projectionRms->GetMean() - 2. * projectionRes->GetRMS() - 0.2;
2038 xmax = projectionRms->GetMean() + 2. * projectionRes->GetRMS() + 0.2;
2040 // projectionRms->Fit("gaus","q0","",xmin,xmax);
2041 // Float_t rmsMean = projectionRms->GetFunction("gaus")->GetParameter(1);
2042 // Float_t rmsSigma = projectionRms->GetFunction("gaus")->GetParameter(2);
2043 // Float_t errorRMS = projectionRms->GetFunction("gaus")->GetParError(1);
2044 // Float_t errorSigma = projectionRms->GetFunction("gaus")->GetParError(2);
2045 projectionRms->Fit("fitFunction", "qN0", "", xmin, xmax);
2046 Float_t rmsMean = fitFunction->GetParameter(1);
2047 Float_t rmsSigma = fitFunction->GetParameter(2);
2048 Float_t errorRMS = fitFunction->GetParError(1);
2049 Float_t errorSigma = fitFunction->GetParError(2);
2051 Float_t length = 0.75;
2052 if (ipad == 1) length = 1;
2053 if (ipad == 2) length = 1.5;
2055 fTreeResol<<"Resol"<<
2056 "Entries="<<entries<< // number of entries for this resolution point
2057 "nbins="<<nbins<< // number of bins that were accumulated
2058 "Dim="<<idim<< // direction, Dim==0: y-direction, Dim==1: z-direction
2059 "Pad="<<ipad<< // padSize; short, medium and long
2060 "Length="<<length<< // pad length, 0.75, 1, 1.5
2061 "QMean="<<qMean<< // mean charge of current charge bin and its neighbours, Qmean<0: integrated spectra
2062 "Zc="<<zCenter<< // center of middle bin in drift direction
2063 "Zm="<<zMean<< // mean dirftlength for accumulated Delta-Histograms
2064 "Zs="<<zSigma<< // width of driftlength bin
2065 "AngleC="<<angleCenter<< // center of middle bin in Angle-Direction
2066 "AngleM="<<angleMean<< // mean angle for accumulated Delta-Histograms
2067 "AngleS="<<angleSigma<< // width of Angle-bin
2068 "Resol="<<resol<< // sigma for gaus fit through Delta-Histograms
2069 "Sigma="<<sigma<< // error of sigma for gaus fit through Delta Histograms
2070 "MeanR="<<meanR<< // mean of the Delta-Histogram
2071 "SigmaR="<<sigmaR<< // rms of the Delta-Histogram
2072 "RMSm="<<rmsMean<< // mean of the gaus fit through RMS-Histogram
2073 "RMSs="<<rmsSigma<< // sigma of the gaus fit through RMS-Histogram
2074 "RMSe0="<<errorRMS<< // error of mean of gaus fit in RMS-Histogram
2075 "RMSe1="<<errorSigma<< // error of sigma of gaus fit in RMS-Histogram
2077 if (GetDebugLevel() > 5) {
2078 projectionRes->SetDirectory(fTreeResol.GetFile());
2079 projectionRes->Write(projectionRes->GetName());
2080 projectionRes->SetDirectory(0);
2081 projectionRms->SetDirectory(fTreeResol.GetFile());
2082 projectionRms->Write(projectionRms->GetName());
2083 projectionRes->SetDirectory(0);
2085 } // if (projectionRes->GetSum() > minEntries)
2086 } // for (Int_t ibinxDL = 1; ibinxDL <= xAxisDriftLength->GetNbins(); ibinxDL++)
2087 } // for (Int_t ibinyAngle = 1; ibinyAngle <= yAxisAngle->GetNbins(); ibinyAngle++)
2092 delete projectionRes;
2093 delete projectionRms;
2095 // TFile resolFile(fTreeResol.GetFile());
2096 TObjString fileInfo(Form("Resolution tree, minEntries = %i", minEntries));
2097 fileInfo.Write("fileInfo");
2098 // resolFile.Close();
2099 // fTreeResol.GetFile()->Close();
2100 if (GetDebugLevel() > -1) cout << endl;
2101 if (GetDebugLevel() > -1) cout << "MakeResPlotsQTree done, results are in '"<< kFileName.Data() <<"'." << endl;
2102 gSystem->ChangeDirectory("..");
2109 Long64_t AliTPCcalibTracks::Merge(TCollection *collectionList) {
2111 // function to merge several AliTPCcalibTracks objects after PROOF calculation
2112 // The object's histograms are merged via their merge functions
2113 // Be carefull: histograms are linked to a file, switch this off by TH1::AddDirectory(kFALSE) !!!
2116 if (GetDebugLevel() > 0) cout << " ***** this is AliTPCcalibTracks::Merge(TCollection *collectionList) *****"<< endl;
2117 if (!collectionList) return 0;
2118 if (collectionList->IsEmpty()) return -1;
2120 if (GetDebugLevel() > 1) cout << "the collectionList contains " << collectionList->GetEntries() << " entries." << endl; // REMOVE THIS LINE!!!!!!!!!!!!!!!!!1
2121 if (GetDebugLevel() > 5) cout << " the list in the merge-function looks as follows: " << endl;
2122 collectionList->Print();
2124 // create a list for each data member
2125 TList* deltaYList = new TList;
2126 TList* deltaZList = new TList;
2127 TList* arrayAmpRowList = new TList;
2128 TList* rejectedTracksList = new TList;
2129 TList* hclusList = new TList;
2130 TList* clusterCutHistoList = new TList;
2131 TList* arrayAmpList = new TList;
2132 TList* arrayQDYList = new TList;
2133 TList* arrayQDZList = new TList;
2134 TList* arrayQRMSYList = new TList;
2135 TList* arrayQRMSZList = new TList;
2136 TList* arrayChargeVsDriftlengthList = new TList;
2137 TList* calPadRegionChargeVsDriftlengthList = new TList;
2138 TList* hclusterPerPadrowList = new TList;
2139 TList* hclusterPerPadrowRawList = new TList;
2140 TList* resolYList = new TList;
2141 TList* resolZList = new TList;
2142 TList* rMSYList = new TList;
2143 TList* rMSZList = new TList;
2145 // TList* nRowsList = new TList;
2146 // TList* nSectList = new TList;
2147 // TList* fileNoList = new TList;
2149 TIterator *listIterator = collectionList->MakeIterator();
2150 AliTPCcalibTracks *calibTracks = 0;
2151 if (GetDebugLevel() > 1) cout << "start to iterate, filling lists" << endl;
2153 while ( (calibTracks = (AliTPCcalibTracks*)listIterator->Next()) ){
2154 // loop over all entries in the collectionList and get dataMembers into lists
2155 if (!calibTracks) continue;
2157 deltaYList->Add( calibTracks->GetfDeltaY() );
2158 deltaZList->Add( calibTracks->GetfDeltaZ() );
2159 arrayAmpRowList->Add(calibTracks->GetfArrayAmpRow());
2160 arrayAmpList->Add(calibTracks->GetfArrayAmp());
2161 arrayQDYList->Add(calibTracks->GetfArrayQDY());
2162 arrayQDZList->Add(calibTracks->GetfArrayQDZ());
2163 arrayQRMSYList->Add(calibTracks->GetfArrayQRMSY());
2164 arrayQRMSZList->Add(calibTracks->GetfArrayQRMSZ());
2165 resolYList->Add(calibTracks->GetfResolY());
2166 resolZList->Add(calibTracks->GetfResolZ());
2167 rMSYList->Add(calibTracks->GetfRMSY());
2168 rMSZList->Add(calibTracks->GetfRMSZ());
2169 arrayChargeVsDriftlengthList->Add(calibTracks->GetfArrayChargeVsDriftlength());
2170 calPadRegionChargeVsDriftlengthList->Add(calibTracks->GetCalPadRegionchargeVsDriftlength());
2171 hclusList->Add(calibTracks->GetfHclus());
2172 rejectedTracksList->Add(calibTracks->GetfRejectedTracksHisto());
2173 clusterCutHistoList->Add(calibTracks->GetfClusterCutHisto());
2174 hclusterPerPadrowList->Add(calibTracks->GetfHclusterPerPadrow());
2175 hclusterPerPadrowRawList->Add(calibTracks->GetfHclusterPerPadrowRaw());
2176 fCalPadClusterPerPad->Add(calibTracks->GetfCalPadClusterPerPad());
2177 fCalPadClusterPerPadRaw->Add(calibTracks->GetfCalPadClusterPerPadRaw());
2179 if (GetDebugLevel() > 5) cout << "filling lists, object " << counter << " added." << endl;
2183 // merge data members
2184 if (GetDebugLevel() > 0) cout << "histogram's merge-functins are called... " << endl;
2185 fDeltaY->Merge(deltaYList);
2186 fDeltaZ->Merge(deltaZList);
2187 fHclus->Merge(hclusList);
2188 fClusterCutHisto->Merge(clusterCutHistoList);
2189 fRejectedTracksHisto->Merge(rejectedTracksList);
2190 fHclusterPerPadrow->Merge(hclusterPerPadrowList);
2191 fHclusterPerPadrowRaw->Merge(hclusterPerPadrowRawList);
2193 TObjArray* objarray = 0;
2195 TList* histList = 0;
2196 TIterator *objListIterator = 0;
2198 if (GetDebugLevel() > 0) cout << "merging fArrayAmpRows..." << endl;
2199 // merge fArrayAmpRows
2200 for (Int_t i = 0; i < fArrayAmpRow->GetEntriesFast(); i++ ) { // loop over data member, i<72
2201 objListIterator = arrayAmpRowList->MakeIterator();
2202 histList = new TList;
2203 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2204 // loop over arrayAmpRowList, get TObjArray, get object at position i, cast it into TProfile
2205 if (!objarray) continue;
2206 hist = (TProfile*)(objarray->At(i));
2207 histList->Add(hist);
2209 ((TProfile*)(fArrayAmpRow->At(i)))->Merge(histList);
2211 delete objListIterator;
2214 if (GetDebugLevel() > 0) cout << "merging fArrayAmps..." << endl;
2216 for (Int_t i = 0; i < fArrayAmp->GetEntriesFast(); i++ ) { // loop over data member, i<72
2217 TIterator *objListIterator = arrayAmpList->MakeIterator();
2218 histList = new TList;
2219 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2220 // loop over arrayAmpList, get TObjArray, get object at position i, cast it into TH1F
2221 if (!objarray) continue;
2222 hist = (TH1F*)(objarray->At(i));
2223 histList->Add(hist);
2225 ((TH1F*)(fArrayAmp->At(i)))->Merge(histList);
2227 delete objListIterator;
2230 if (GetDebugLevel() > 0) cout << "merging fArrayQDY..." << endl;
2232 for (Int_t i = 0; i < fArrayQDY->GetEntriesFast(); i++) { // loop over data member, i < 300
2233 objListIterator = arrayQDYList->MakeIterator();
2234 histList = new TList;
2235 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2236 // loop over arrayQDYList, get TObjArray, get object at position i, cast it into TH3F
2237 if (!objarray) continue;
2238 hist = (TH3F*)(objarray->At(i));
2239 histList->Add(hist);
2241 ((TH3F*)(fArrayQDY->At(i)))->Merge(histList);
2243 delete objListIterator;
2246 if (GetDebugLevel() > 0) cout << "merging fArrayQDZ..." << endl;
2248 for (Int_t i = 0; i < fArrayQDZ->GetEntriesFast(); i++) { // loop over data member, i < 300
2249 objListIterator = arrayQDZList->MakeIterator();
2250 histList = new TList;
2251 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2252 // loop over arrayQDZList, get TObjArray, get object at position i, cast it into TH3F
2253 if (!objarray) continue;
2254 hist = (TH3F*)(objarray->At(i));
2255 histList->Add(hist);
2257 ((TH3F*)(fArrayQDZ->At(i)))->Merge(histList);
2259 delete objListIterator;
2262 if (GetDebugLevel() > 0) cout << "merging fArrayQRMSY..." << endl;
2263 // merge fArrayQRMSY
2264 for (Int_t i = 0; i < fArrayQRMSY->GetEntriesFast(); i++) { // loop over data member, i < 300
2265 objListIterator = arrayQRMSYList->MakeIterator();
2266 histList = new TList;
2267 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2268 // loop over arrayQDZList, get TObjArray, get object at position i, cast it into TH3F
2269 if (!objarray) continue;
2270 hist = (TH3F*)(objarray->At(i));
2271 histList->Add(hist);
2273 ((TH3F*)(fArrayQRMSY->At(i)))->Merge(histList);
2275 delete objListIterator;
2278 if (GetDebugLevel() > 0) cout << "merging fArrayQRMSZ..." << endl;
2279 // merge fArrayQRMSZ
2280 for (Int_t i = 0; i < fArrayQRMSZ->GetEntriesFast(); i++) { // loop over data member, i < 300
2281 objListIterator = arrayQRMSZList->MakeIterator();
2282 histList = new TList;
2283 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2284 // loop over arrayQDZList, get TObjArray, get object at position i, cast it into TH3F
2285 if (!objarray) continue;
2286 hist = (TH3F*)(objarray->At(i));
2287 histList->Add(hist);
2289 ((TH3F*)(fArrayQRMSZ->At(i)))->Merge(histList);
2291 delete objListIterator;
2294 if (GetDebugLevel() > 0) cout << "merging fArrayChargeVsDriftlength..." << endl;
2295 // merge fArrayChargeVsDriftlength
2296 for (Int_t i = 0; i < fArrayChargeVsDriftlength->GetEntriesFast(); i++) { // loop over data member, i < 300
2297 objListIterator = arrayChargeVsDriftlengthList->MakeIterator();
2298 histList = new TList;
2299 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2300 // loop over arrayQDZList, get TObjArray, get object at position i, cast it into TProfile
2301 if (!objarray) continue;
2302 hist = (TProfile*)(objarray->At(i));
2303 histList->Add(hist);
2305 ((TProfile*)(fArrayChargeVsDriftlength->At(i)))->Merge(histList);
2307 delete objListIterator;
2310 if (GetDebugLevel() > 0) cout << "merging fcalPadRegionChargeVsDriftlength..." << endl;
2311 // merge fcalPadRegionChargeVsDriftlength
2312 AliTPCCalPadRegion *cpr = 0x0;
2315 TIterator *regionIterator = fcalPadRegionChargeVsDriftlength->MakeIterator();
2316 while (hist = (TProfile*)regionIterator->Next()) {
2317 // loop over all calPadRegion's in destination calibTracks object
2318 objListIterator = calPadRegionChargeVsDriftlengthList->MakeIterator();
2319 while (( cpr = (AliTPCCalPadRegion*)objListIterator->Next() )) {
2326 for (UInt_t isec = 0; isec < 36; isec++) {
2327 for (UInt_t padSize = 0; padSize < 3; padSize++){
2328 objListIterator = calPadRegionChargeVsDriftlengthList->MakeIterator();
2329 histList = new TList;
2330 while (( cpr = (AliTPCCalPadRegion*)objListIterator->Next() )) {
2331 // loop over calPadRegionChargeVsDriftlengthList, get AliTPCCalPadRegion, get object
2333 hist = (TProfile*)cpr->GetObject(isec, padSize);
2334 histList->Add(hist);
2336 ((TProfile*)(fcalPadRegionChargeVsDriftlength->GetObject(isec, padSize)))->Merge(histList);
2338 delete objListIterator;
2345 if (GetDebugLevel() > 0) cout << "starting to merge the rest: fResolY, fResolZ , fRMSY, fRMSZ..." << endl;
2347 for (Int_t i = 0; i < fResolY->GetEntriesFast(); i++) { // loop over data member, i < 3
2348 objListIterator = resolYList->MakeIterator();
2349 histList = new TList;
2350 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2351 // loop over arrayQDZList, get TObjArray, get object at position i, cast it into TH3F
2352 if (!objarray) continue;
2353 hist = (TH3F*)(objarray->At(i));
2354 histList->Add(hist);
2356 ((TH3F*)(fResolY->At(i)))->Merge(histList);
2358 delete objListIterator;
2362 for (Int_t i = 0; i < fResolZ->GetEntriesFast(); i++) { // loop over data member, i < 3
2363 objListIterator = resolZList->MakeIterator();
2364 histList = new TList;
2365 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2366 // loop over arrayQDZList, get TObjArray, get object at position i, cast it into TH3F
2367 if (!objarray) continue;
2368 hist = (TH3F*)(objarray->At(i));
2369 histList->Add(hist);
2371 ((TH3F*)(fResolZ->At(i)))->Merge(histList);
2373 delete objListIterator;
2377 for (Int_t i = 0; i < fRMSY->GetEntriesFast(); i++) { // loop over data member, i < 3
2378 objListIterator = rMSYList->MakeIterator();
2379 histList = new TList;
2380 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2381 // loop over arrayQDZList, get TObjArray, get object at position i, cast it into TH3F
2382 if (!objarray) continue;
2383 hist = (TH3F*)(objarray->At(i));
2384 histList->Add(hist);
2386 ((TH3F*)(fRMSY->At(i)))->Merge(histList);
2388 delete objListIterator;
2392 for (Int_t i = 0; i < fRMSZ->GetEntriesFast(); i++) { // loop over data member, i < 3
2393 objListIterator = rMSZList->MakeIterator();
2394 histList = new TList;
2395 while (( objarray = (TObjArray*)objListIterator->Next() )) {
2396 // loop over arrayQDZList, get TObjArray, get object at position i, cast it into TH3F
2397 if (!objarray) continue;
2398 hist = (TH3F*)(objarray->At(i));
2399 histList->Add(hist);
2401 ((TH3F*)(fRMSZ->At(i)))->Merge(histList);
2403 delete objListIterator;
2408 delete arrayAmpRowList;
2409 delete arrayAmpList;
2410 delete arrayQDYList;
2411 delete arrayQDZList;
2412 delete arrayQRMSYList;
2413 delete arrayQRMSZList;
2418 delete listIterator;
2420 if (GetDebugLevel() > 0) cout << "merging done!" << endl;
2426 AliTPCcalibTracks* AliTPCcalibTracks::TestMerge(AliTPCcalibTracks *ct, AliTPCClusterParam *clusterParam, Int_t nCalTracks){
2428 // function to test AliTPCcalibTrack::Merge:
2429 // in the file 'f' is a AliTPCcalibTrack object with name "calibTracks"
2430 // this object is appended 'nCalTracks' times to a TList
2431 // A new AliTPCcalibTrack object is created which merges the list
2432 // this object is returned
2435 // .L AliTPCcalibTracks.cxx+g
2437 TFile f("Output.root");
2438 AliTPCcalibTracks* calTracks = (AliTPCcalibTracks*)f.Get("calibTracks");
2440 TFile clusterParamFile("/u/lbozyk/calibration/workdir/calibTracks/TPCClusterParam.root");
2441 AliTPCClusterParam *clusterParam = (AliTPCClusterParam *) clusterParamFile.Get("Param");
2442 clusterParamFile.Close();
2444 AliTPCcalibTracks::TestMerge(calTracks, clusterParam);
2446 TList *list = new TList();
2447 if (ct == 0 || clusterParam == 0) return 0;
2448 cout << "making list with " << nCalTracks << " AliTPCcalibTrack objects" << endl;
2449 for (Int_t i = 0; i < nCalTracks; i++) {
2450 if (i%10==0) cout << "Adding element " << i << " of " << nCalTracks << endl;
2451 list->Add(new AliTPCcalibTracks(*ct));
2454 // only for check at the end
2455 AliTPCcalibTracks* cal1 = new AliTPCcalibTracks(*ct);
2456 Double_t cal1Entries = ((TH1F*)cal1->GetfArrayAmpRow()->At(5))->GetEntries();
2457 // Double_t cal1Entries = 5; //((TH1F*)ct->GetfArrayAmpRow()->At(5))->GetEntries();
2459 cout << "The list contains " << list->GetEntries() << " entries. " << endl;
2462 AliTPCcalibTracksCuts *cuts = new AliTPCcalibTracksCuts(20, 0.4, 0.5, 0.13, 0.018);
2463 AliTPCcalibTracks* cal = new AliTPCcalibTracks("calTracksMerged", "calTracksMerged", clusterParam, cuts, 5);
2466 cout << "cal->GetfArrayAmpRow()->At(5)->Print():" << endl;
2467 cal->GetfArrayAmpRow()->At(5)->Print();
2468 Double_t calEntries = ((TH1F*)cal->GetfArrayAmpRow()->At(5))->GetEntries();
2470 cout << "cal1->GetfArrayAmpRow()->At(5))->GetEntries() = " << cal1Entries << endl;
2471 cout << " cal->GetfArrayAmpRow()->At(5))->GetEntries() = " << calEntries << endl;
2472 printf("That means there were %f / %f = %f AliTPCcalibTracks-Objects merged. \n",
2473 calEntries, cal1Entries, ((Double_t)calEntries/cal1Entries));