AliRoot Core  a565103 (a565103)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliMUONRecoParam.cxx
Go to the documentation of this file.
1 /**************************************************************************
2 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15 
16 // $Id$
17 
18 //-----------------------------------------------------------------------------
24 //-----------------------------------------------------------------------------
25 
26 
27 
28 #include "AliMUONRecoParam.h"
29 #include "AliMUONPadStatusMaker.h"
30 
31 #include "AliRecoParam.h"
32 #include "AliLog.h"
33 
34 #include "AliCDBManager.h"
35 #include "AliCDBEntry.h"
36 
37 #include <Riostream.h>
38 
39 using std::cout;
40 using std::endl;
42 
43 
44 //_____________________________________________________________________________
46 : AliDetectorRecoParam(),
47  fClusteringMode("MLEM"),
48  fTrackingMode("KALMAN"),
49  fMinBendingMomentum(0.),
50  fMaxBendingMomentum(0.),
51  fMaxNonBendingSlope(0.),
52  fMaxBendingSlope(0.),
53  fNonBendingVertexDispersion(0.),
54  fBendingVertexDispersion(0.),
55  fMaxNonBendingDistanceToTrack(0.),
56  fMaxBendingDistanceToTrack(0.),
57  fSigmaCutForTracking(0.),
58  fSigmaCutForImprovement(0.),
59  fSigmaCutForTrigger(0.),
60  fStripCutForTrigger(0.),
61  fMaxStripAreaForTrigger(0.),
62  fMaxNormChi2MatchTrigger(0.),
63  fPercentOfFullClusterInESD(10.),
64  fCombinedClusterTrackReco(kFALSE),
65  fTrackAllTracks(kFALSE),
66  fRecoverTracks(kFALSE),
67  fMakeTrackCandidatesFast(kFALSE),
68  fMakeMoreTrackCandidates(kFALSE),
69  fComplementTracks(kFALSE),
70  fImproveTracks(kFALSE),
71  fUseSmoother(kFALSE),
72  fSaveFullClusterInESD(kTRUE),
73  fBypassSt45(0),
74  fPadGoodnessMask(0),
75  fChargeSigmaCut(4.0),
76  fRemoveConnectedTracksInSt12(kFALSE),
77  fMaxTriggerTracks(0),
78  fMaxTrackCandidates(0),
79  fSelectTrackOnSlope(kFALSE),
80  fMissingPadFractionLimit(-1),
81  fFractionOfBuspatchOutsideOccupancyLimit(0),
82  fAverageNoisePadCharge(0.22875),
83  fClusterChargeCut(2.0),
84  fEventSizeSoftLimit(35.0),
85  fEventSizeHardLimit(45.0),
86  fTokenLostLimit(0.0),
87  fTryRecover(kFALSE),
88  fDiscardMonoCathodClusters(kFALSE),
89  fMonoCathodClNonBendingRes(0.),
90  fMonoCathodClBendingRes(0.)
91 {
93 
94  SetNameTitle("Dummy","Dummy");
95  for (Int_t iCh = 0; iCh < 10; iCh++) {
96  fUseChamber[iCh] = kTRUE;
97  fDefaultNonBendingReso[iCh] = 0.;
98  fDefaultBendingReso[iCh] = 0.;
99  }
100  for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
101  SetDefaultLimits();
102 }
103 
104 //_____________________________________________________________________________
106 {
108 }
109 
110 //_____________________________________________________________________________
111 void
112 AliMUONRecoParam::BypassSt45(Bool_t st4, Bool_t st5)
113 {
115 
116  if ( st4 && st5 ) fBypassSt45 = 45;
117  else if ( st4 ) fBypassSt45 = 4;
118  else if ( st5 ) fBypassSt45 = 5;
119  else fBypassSt45 = 0;
120 }
121 
122 //_____________________________________________________________________________
124 {
126 
127  AliMUONRecoParam *param = new AliMUONRecoParam();
128  param->SetLowFluxParam();
129 
130  return param;
131 }
132 
133 //_____________________________________________________________________________
135 {
137 
138  AliMUONRecoParam *param = new AliMUONRecoParam();
139  param->SetHighFluxParam();
140 
141  return param;
142 }
143 
144 //_____________________________________________________________________________
146 {
148 
149  AliMUONRecoParam *param = new AliMUONRecoParam();
150  param->SetCosmicParam();
151 
152  return param;
153 }
154 
155 //_____________________________________________________________________________
157 {
159 
160  AliMUONRecoParam *param = new AliMUONRecoParam();
161  param->SetCalibrationParam();
162 
163  return param;
164 }
165 
166 
167 //_____________________________________________________________________________
169 {
171 
172  SetNameTitle("Low Flux","Low Flux");
173  SetEventSpecie(AliRecoParam::kLowMult);
174  fMinBendingMomentum = 0.8;
175  fMaxBendingMomentum = 1.e10;
176  fMaxNonBendingSlope = 0.3;
177  fMaxBendingSlope = 0.4;
178  fSelectTrackOnSlope = kFALSE;
185  fSigmaCutForTrigger = 4.;
186  fStripCutForTrigger = 1.;
189  fCombinedClusterTrackReco = kFALSE;
190  fTrackAllTracks = kTRUE;
191  fRecoverTracks = kTRUE;
192  fMakeTrackCandidatesFast = kFALSE;
193  fMakeMoreTrackCandidates = kFALSE;
194  fComplementTracks = kTRUE;
195  fImproveTracks = kTRUE;
197  fUseSmoother = kTRUE;
198  for (Int_t iCh = 0; iCh < 10; iCh++) {
199  fUseChamber[iCh] = kTRUE;
200  fDefaultNonBendingReso[iCh] = 0.144;
201  fDefaultBendingReso[iCh] = 0.01;
202  }
203  for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
204  fBypassSt45 = 0;
205  fMaxTriggerTracks = 100;
206  fMaxTrackCandidates = 10000;
210 }
211 
212 //_____________________________________________________________________________
214 {
216 
217  SetNameTitle("High Flux","High Flux");
218  SetEventSpecie(AliRecoParam::kHighMult);
219  fMinBendingMomentum = 0.8;
220  fMaxBendingMomentum = 1.e10;
221  fMaxNonBendingSlope = 0.3;
222  fMaxBendingSlope = 0.4;
223  fSelectTrackOnSlope = kFALSE;
230  fSigmaCutForTrigger = 4.;
231  fStripCutForTrigger = 1.;
234  fCombinedClusterTrackReco = kFALSE;
235  fTrackAllTracks = kTRUE;
236  fRecoverTracks = kTRUE;
237  fMakeTrackCandidatesFast = kFALSE;
238  fMakeMoreTrackCandidates = kFALSE;
239  fComplementTracks = kTRUE;
240  fImproveTracks = kTRUE;
242  fUseSmoother = kTRUE;
243  for (Int_t iCh = 0; iCh < 10; iCh++) {
244  fUseChamber[iCh] = kTRUE;
245  fDefaultNonBendingReso[iCh] = 0.144;
246  fDefaultBendingReso[iCh] = 0.01;
247  }
248  for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
249  fBypassSt45 = 0;
250  fMaxTriggerTracks = 100;
251  fMaxTrackCandidates = 10000;
255 }
256 
257 //_____________________________________________________________________________
259 {
261 
262  SetNameTitle("Cosmic","Cosmic");
263  SetEventSpecie(AliRecoParam::kCosmic);
264  fMinBendingMomentum = 0.8;
265  fMaxBendingMomentum = 1.e10;
266  fMaxNonBendingSlope = 0.3;
267  fMaxBendingSlope = 0.4;
268  fSelectTrackOnSlope = kTRUE;
275  fSigmaCutForTrigger = 4.;
276  fStripCutForTrigger = 1.5;
280  fCombinedClusterTrackReco = kFALSE;
281  fTrackAllTracks = kTRUE;
282  fRecoverTracks = kTRUE;
283  fMakeTrackCandidatesFast = kFALSE;
284  fMakeMoreTrackCandidates = kFALSE;
285  fComplementTracks = kTRUE;
286  fImproveTracks = kTRUE;
288  fUseSmoother = kTRUE;
289  fSaveFullClusterInESD = kTRUE;
290  for (Int_t iCh = 0; iCh < 10; iCh++) {
291  fUseChamber[iCh] = kTRUE;
292  fDefaultNonBendingReso[iCh] = 0.4;
293  fDefaultBendingReso[iCh] = 0.4;
294  }
295  fRequestStation[0] = kTRUE;
296  fRequestStation[1] = kTRUE;
297  fRequestStation[2] = kTRUE;
298  fRequestStation[3] = kTRUE;
299  fRequestStation[4] = kTRUE;
300  fBypassSt45 = 0;
301  fPadGoodnessMask = 0x400BE80; // Ped Mean is Zero | Ped Mean Too Low | Ped Mean Too High | Ped Sigma Too Low | Ped Sigma Too High | Ped is missing | HV is missing | manu occupancy too high
302  fMaxTriggerTracks = 100;
303  fMaxTrackCandidates = 10000;
307 
308  SetPedMeanLimits(20, 700);
309  SetManuOccupancyLimits(-1.,0.01); // reject manu above occ=1%
310 
311  SetBuspatchOccupancyLimits(-1,0.05);
313 }
314 
315 
316 //_____________________________________________________________________________
318 {
320 
321  SetNameTitle("Calibration","Calibration");
322  SetEventSpecie(AliRecoParam::kCalib);
323 
324  fPedMeanLimits[0] = 5000;
325  fPedMeanLimits[1] = 0;
326 
327  fPadGoodnessMask = 0x8C00; // Pedestal is missing | is too low | too high
328 
329 }
330 
331 //_____________________________________________________________________________
332 UInt_t
334 {
337 
338  UInt_t m(0);
339 
340  for ( Int_t i = 0; i < 5; ++i )
341  {
342  if ( RequestStation(i) ) m |= ( 1 << i );
343  }
344  return m;
345 }
346 
347 //_____________________________________________________________________________
348 void AliMUONRecoParam::Print(Option_t *option) const
349 {
352 
353  cout<<endl<<"\t------MUON Reconstruction parameters ("<<GetName()<<")------"<<endl;
354 
355  if (IsDefault()) cout<<"\t\t*** Parameters used by default ***"<<endl;
356 
357  cout << "Event Specie=" << GetEventSpecie() << endl;
358 
359  cout<<Form("Clustering mode = %s",fClusteringMode.Data())<<endl;
360  cout<<Form("Tracking mode = %s",fTrackingMode.Data())<<endl;
361 
362  TString bypass;
363 
364  if ( BypassSt45() )
365  {
366  bypass = "stations 4 and 5";
367  }
368  else if ( BypassSt4() )
369  {
370  bypass = "station 4";
371  }
372  else if ( BypassSt5() )
373  {
374  bypass = "station 5";
375  }
376 
377  if (bypass.Length()) cout << "Will bypass " << bypass.Data() << " (replacing real clusters by generated ones from trigger tracks)" << endl;
378 
379  if (fCombinedClusterTrackReco) cout<<"Combined cluster/track reconstruction: ON"<<endl;
380  else cout<<"Combined cluster/track reconstruction: OFF"<<endl;
381 
382  if (fSaveFullClusterInESD) cout<<Form("Save all cluster info in ESD for %5.2f %% of events",fPercentOfFullClusterInESD)<<endl;
383  else cout<<"Save partial cluster info in ESD"<<endl;
384 
385  cout<<"Selection of track candidates:"<<endl;
386  if (fSelectTrackOnSlope) cout<<Form("\t- Non-bending slope < %5.2f",fMaxNonBendingSlope)<<endl;
387  else cout<<"\t- Impact parameter < 3 * vertex dispersion in the non-bending direction"<<endl;
388  cout<<Form("\t- if B!=0: Bending momentum > %5.2f",fMinBendingMomentum)<<endl;
389  if (fSelectTrackOnSlope) cout<<Form("\t if B==0: Bending slope < %5.2f",fMaxBendingSlope)<<endl;
390  else cout<<"\t if B==0: Impact parameter < 3 * vertex dispersion in the bending direction"<<endl;
391 
392  cout<<Form("Vertex dispersion (used to estimate initial bending momentum resolution) = (%5.2f,%5.2f)",fNonBendingVertexDispersion,fBendingVertexDispersion)<<endl;
393 
394  cout<<Form("Maximum distance to track = (%5.2f,%5.2f)",fMaxNonBendingDistanceToTrack,fMaxBendingDistanceToTrack)<<endl;
395 
396  cout<<Form("Sigma cut for tracking = %5.2f",fSigmaCutForTracking)<<endl;
397 
398  cout<<Form("Sigma cut for trigger hit pattern = %5.2f",fSigmaCutForTrigger)<<endl;
399 
400  cout<<Form("Cut in strips for trigger chamber efficiency = %5.2f",fStripCutForTrigger)<<endl;
401 
402  cout<<Form("Max search area in strips for trigger chamber efficiency = %5.2f",fMaxStripAreaForTrigger)<<endl;
403 
404  if (fTrackAllTracks) cout<<"Track all the possible candidates"<<endl;
405  else cout<<"Track only the best candidates"<<endl;
406 
407  if (strstr(option,"FULL")) {
408  cout<<"Make track candidates assuming linear propagation between stations 4 and 5: ";
409  if (fMakeTrackCandidatesFast) cout<<"ON"<<endl;
410  else cout<<"OFF"<<endl;
411  } else if (fMakeTrackCandidatesFast)
412  cout<<"Make track candidates assuming linear propagation between stations 4 and 5"<<endl;
413 
414  if (strstr(option,"FULL")) {
415  cout<<"Make track candidates starting from 1 cluster in each of the stations 4 and 5: ";
416  if (fMakeMoreTrackCandidates) cout<<"ON"<<endl;
417  else cout<<"OFF"<<endl;
418  } else if (fMakeMoreTrackCandidates)
419  cout<<"Make track candidates starting from 1 cluster in each of the stations 4 and 5"<<endl;
420 
421  if (strstr(option,"FULL")) {
422  cout<<"Try to recover tracks getting lost during tracking: ";
423  if (fRecoverTracks) cout<<"ON"<<endl;
424  else cout<<"OFF"<<endl;
425  } else if (fRecoverTracks)
426  cout<<"Try to recover tracks getting lost during tracking"<<endl;
427 
428  if (strstr(option,"FULL")) {
429  cout<<"Try to complete the reconstructed tracks by adding missing clusters: ";
430  if (fComplementTracks) cout<<"ON"<<endl;
431  else cout<<"OFF"<<endl;
432  } else if (fComplementTracks)
433  cout<<"Try to complete the reconstructed tracks by adding missing clusters"<<endl;
434 
435  if (strstr(option,"FULL")) {
436  cout<<"Try to improve the reconstructed tracks by removing bad clusters: ";
437  if (fImproveTracks) cout<<Form("ON (sigma cut = %5.2f)",fSigmaCutForImprovement)<<endl;
438  else cout<<"OFF"<<endl;
439  } else if (fImproveTracks)
440  cout<<Form("Try to improve the reconstructed tracks by removing bad clusters (sigma cut = %5.2f)",fSigmaCutForImprovement)<<endl;
441 
442  if (fRemoveConnectedTracksInSt12) cout<<"Remove tracks sharing one cluster or more in any station"<<endl;
443  else cout<<"Remove tracks sharing one cluster or more in stations 3, 4 and 5"<<endl;
444 
445  if (strstr(option,"FULL")) {
446  cout<<"Use smoother to compute final track parameters, etc, at each cluster (used for Kalman tracking only): ";
447  if (fUseSmoother) cout<<"ON"<<endl;
448  else cout<<"OFF"<<endl;
449  } else if (fUseSmoother)
450  cout<<"Use smoother to compute final track parameters, etc, at each cluster"<<endl;
451 
452  cout<<Form("Maximum normalized chi2 of tracking/trigger track matching = %5.2f",fMaxNormChi2MatchTrigger)<<endl;
453 
454  Bool_t discardedCh = kFALSE;
455  Int_t ch = 0;
456  do {
457  if (!UseChamber(ch)) {
458  if (!discardedCh) {
459  cout<<"Discarded chambers(1..): "<<ch+1;
460  discardedCh = kTRUE;
461  }
462  else cout<<" "<<ch+1;
463  }
464  } while (++ch < 10);
465  if (discardedCh) cout<<endl;
466 
467  Bool_t discardedSt = kFALSE;
468  Int_t st = 0;
469  do {
470  if (!RequestStation(st)) {
471  if (!discardedSt) {
472  cout<<"Not requested stations(1..): "<<st+1;
473  discardedSt = kTRUE;
474  }
475  else cout<<" "<<st+1;
476  }
477  } while (++st < 5);
478  if (discardedSt) cout<<endl;
479 
480  cout << Form("Pad goodness policy mask is 0x%x",PadGoodnessMask()) << endl;
481  cout << "Which means we reject pads having the condition = " <<
483 
484  cout << "The pad limits we are using are :" << endl;
485 
486  for ( int ichamber = 0; ichamber < 10; ++ichamber )
487  {
488  cout << Form("HV Ch %d must be >= %5.2f",ichamber,HVLimit(ichamber)) << endl;
489  }
490 
491  cout << Form("%7.2f <= Pedestal mean <= %7.2f",PedMeanLowLimit(),PedMeanHighLimit()) << endl;
492  cout << Form("%7.2f <= Pedestal sigma <= %7.2f",PedSigmaLowLimit(),PedSigmaHighLimit()) << endl;
493 
494  cout << Form("And we cut on charge >= %7.2f x ( pedestal sigma ) ",ChargeSigmaCut()) << endl;
495 
496  cout << "Occupancy limits are :" << endl;
497 
498  cout << Form("%e <= Manu occupancy < %7.3f",ManuOccupancyLowLimit(),ManuOccupancyHighLimit()) << endl;
499  cout << Form("%e <= Buspatch occupancy < %7.3f",BuspatchOccupancyLowLimit(),BuspatchOccupancyHighLimit()) << endl;
500  cout << Form("%e <= DE occupancy < %7.3f",DEOccupancyLowLimit(),DEOccupancyHighLimit()) << endl;
501 
502  cout << "'QAChecker' limits" << endl;
503  cout << Form("FractionOfBuspatchOutsideOccupancyLimit = %5.2f %%",FractionOfBuspatchOutsideOccupancyLimit()*100.0) << endl;
504  cout << Form("Event size limit = %5.2f KB/event (soft) and %5.2f KB/event (hard)",fEventSizeSoftLimit,fEventSizeHardLimit) << endl;
505  if ( fTokenLostLimit > 0 )
506  {
507  cout << Form("We tolerate up to %5.2f %% token lost errors per event",fTokenLostLimit) << endl;
508  }
509  else
510  {
511  cout << "We dot not tolerate any token lost error !" << endl;
512  }
513 
514  cout << "chamber non bending resolution = |";
515  for (Int_t iCh = 0; iCh < 10; iCh++) cout << Form(" %6.3f |",fDefaultNonBendingReso[iCh]);
516  cout << endl;
517  cout << "chamber bending resolution = |";
518  for (Int_t iCh = 0; iCh < 10; iCh++) cout << Form(" %6.3f |",fDefaultBendingReso[iCh]);
519  cout << endl;
520  cout<<Form("maximum number of trigger tracks above which the tracking is cancelled = %d",fMaxTriggerTracks)<<endl;
521  cout<<Form("maximum number of track candidates above which the tracking is abandonned = %d",fMaxTrackCandidates)<<endl;
522 
523  cout << Form("The average noise pad charge is assumed to be %7.2f fC",AverageNoisePadCharge()) << endl;
524  cout << Form("and clusters below %5.2f times this noise charge (i.e. %7.2f fC) are discarded",
526  cout << Form("Note that LowestPadCharge is then %7.2f fC",LowestPadCharge()) << endl;
527 
528  if (strstr(option,"FULL")) {
529  cout<<"Try to improve the reconstructed tracks by changing the resolution of mono-cathod clusters: ";
530  if (fDiscardMonoCathodClusters) cout<<Form("ON (res = %6.3f, %6.3f)",fMonoCathodClNonBendingRes,fMonoCathodClBendingRes)<<endl;
531  else cout<<"OFF"<<endl;
532  } else if (fDiscardMonoCathodClusters)
533  cout<<Form("Try to improve the reconstructed tracks by changing the resolution of mono-cathod clusters (res = %6.3f, %6.3f)",
535 
536  if (TryRecover())
537  {
538  cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;
539  cout << "!!! WILL TRY TO RECOVER CORRUPTED RAW DATA !!!" << endl;
540  cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;
541  }
542  cout<<"\t-----------------------------------------------------"<<endl<<endl;
543 
544 }
545 
546 //_____________________________________________________________________________
547 void
548 AliMUONRecoParam::SetHVLimit(Int_t chamberId, Double_t value)
549 {
552 
553  if ( chamberId == -1 )
554  {
555  for ( Int_t i = 0; i < 10; ++i )
556  {
557  fHVLimit[i] = value;
558  }
559  }
560  else if ( chamberId >= 0 && chamberId < 10 )
561  {
562  fHVLimit[chamberId]=value;
563  }
564  else
565  {
566  AliError(Form("chamberId = %d is not a valid chamberId",chamberId));
567  }
568 }
569 
570 //_____________________________________________________________________________
571 Double_t AliMUONRecoParam::HVLimit(Int_t chamberId) const
572 {
574  if ( chamberId >= 0 && chamberId < 10 )
575  {
576  return fHVLimit[chamberId];
577  }
578  AliError(Form("chamberId = %d is not a valid chamberId",chamberId));
579 
580  return 0.0;
581 }
582 
583 //_____________________________________________________________________________
584 void
586 {
588 
589  fHVSt12Limits[0]=1500; // kept for backward compatibility only
590  fHVSt12Limits[1]=2000; // kept for backward compatibility only
591  fHVSt345Limits[0]=1500; // kept for backward compatibility only
592  fHVSt345Limits[1]=2000; // kept for backward compatibility only
593 
594  SetHVLimit(-1,1590); // this one is the real HV limit used now
595 
596  fPedMeanLimits[0] = 20;
597  fPedMeanLimits[1] = 1024;
598 
599  fPedSigmaLimits[0] = 0.6;
600  fPedSigmaLimits[1] = 100;
601 
602  fPadGoodnessMask = 0x8080; // Ped is missing | HV is missing
603 
604  fManuOccupancyLimits[0] = -1.0;
605  fManuOccupancyLimits[1] = 1.0;
606 
607  fBuspatchOccupancyLimits[0] = 1E-6;
608  fBuspatchOccupancyLimits[1] = 1.0;
609 
610  fDEOccupancyLimits[0] = -1.0;
611  fDEOccupancyLimits[1] = 1.0;
612 
613  fMissingPadFractionLimit = -1; // DEPRECATED
615 
616  ChargeSigmaCut(4.0); // pad with charge < 4.0 x sigma will be removed (where sigma is the actual noise of that very pad, i.e. not the average)
617 
618  AverageNoisePadCharge(0.22875); // 0.22875 coulombs ~ 1.5 ADC channels
619 
620  ClusterChargeCut(2.0); // will cut cluster below 2.0 x LowestPadCharge()
621 
622  SetEventSizeLimits(35.0,45.0);
623 
624  SetTokenLostLimit(0.0);
625 
626  fTryRecover = kFALSE;
627 }
628 
629 
630 //-----------------------------------------------------------------------
631 TObjArray*
632 AliMUONRecoParam::Create(const char* settings)
633 {
654 
655  AliMUONRecoParam* param(0x0);
656 
657  AliRecoParam::EventSpecie_t defaultParam = AliRecoParam::kLowMult;
658 
659  TString stype(settings);
660  stype.ToLower();
661 
662  if ( stype == "cosmics" )
663  {
664  // set parameters for cosmic runs
666  defaultParam = AliRecoParam::kCosmic;
667  }
668  else if ( stype == "ppideal" )
669  {
670  // set default lowFlux parameters
672  }
673  else if ( stype == "ppreal" || stype == "pprealsim" || stype == "pprealnofield" )
674  {
675  // common parameters for p-p data and realistic p-p simu
677  param->SaveFullClusterInESD(kTRUE, 100.);
678  for (Int_t iCh=0; iCh<10; iCh++)
679  {
680  param->SetDefaultNonBendingReso(iCh,0.4);
681  param->SetDefaultBendingReso(iCh,0.4);
682  }
683  param->SetSigmaCutForTracking(7.);
684  param->SetStripCutForTrigger(1.5);
685  param->SetSigmaCutForTrigger(6.);
686  param->ImproveTracks(kTRUE, 6.);
687  param->SetPedMeanLimits(20, 700);
688  param->SetManuOccupancyLimits(-1.,0.015);
689  param->SetBuspatchOccupancyLimits(-1.,0.05);
690  param->SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 %
691  param->SetEventSizeLimits(45., 65.);
692  param->SetHVLimit(0,1550);
693  param->SetHVLimit(1,1550);
694  param->SetHVLimit(2,1550);
695  param->SetHVLimit(3,1550);
696 
697  // specific parameters for p-p data or realistic p-p simu
698  if ( stype == "ppreal" || stype == "pprealnofield" )
699  {
700  param->SetPadGoodnessMask(0x400BE9B);
701  }
702  else
703  {
704  param->SetPadGoodnessMask(0x8080);
705  }
706 
707  if ( stype == "pprealnofield" )
708  {
709  param->TryRecover(kTRUE);
710  }
711  }
712  else if ( stype == "pbpbreal" || stype == "pbpbrealsim" )
713  {
714  // common parameters for Pb-Pb data and realistic Pb-Pb simu
716  defaultParam = AliRecoParam::kHighMult;
717  param->SaveFullClusterInESD(kTRUE, 100.);
718  for (Int_t iCh=0; iCh<10; iCh++)
719  {
720  param->SetDefaultNonBendingReso(iCh,0.2);
721  param->SetDefaultBendingReso(iCh,0.2);
722  }
723  param->SetSigmaCutForTracking(5.);
724  param->SetStripCutForTrigger(1.5);
725  param->SetSigmaCutForTrigger(4.);
726 // param->MakeMoreTrackCandidates(kTRUE);
727  param->ImproveTracks(kTRUE, 4.);
728  param->SetPedMeanLimits(20, 700);
729  param->SetManuOccupancyLimits(-1.,0.03);
730  param->SetBuspatchOccupancyLimits(-1.,0.1); // 10 % (this cut not used for the reco anyway)
731  param->SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 %
732  param->SetEventSizeLimits(100., 150.);
733  param->DiscardMonoCathodClusters(kTRUE, 10., 10.);
734 
735  // specific parameters for Pb-Pb data or realistic Pb-Pb simu
736  if ( stype == "pbpbreal" )
737  {
738  param->SetPadGoodnessMask(0x400BE9B);
739  }
740  else
741  {
742  param->SetPadGoodnessMask(0x8080);
743  }
744  }
745  else
746  {
747  AliErrorClass("Unknown settings !");
748  return 0x0;
749  }
750 
751  TObjArray* recoParams = new TObjArray;
752 
753  recoParams->AddLast(param);
754 
755  // set (dummy) parameters for calibration runs
757  recoParams->AddLast(param);
758 
759  // set parameters for Pb-Pb runs
760  // param = AliMUONRecoParam::GetHighFluxParam();
761  // recoParams.AddLast(param);
762 
763  // identify default parameters (exit if identification failed)
764  Bool_t defaultIsSet = kFALSE;
765  TIter next(recoParams);
766  while ( (param = static_cast<AliMUONRecoParam*>(next())) )
767  {
768  if (param->GetEventSpecie() == defaultParam)
769  {
770  param->SetAsDefault();
771  defaultIsSet = kTRUE;
772  }
773  param->Print("FULL");
774  }
775 
776  if (!defaultIsSet)
777  {
778  AliErrorClass("The default reconstruction parameters are not set! Exiting...");
779  return 0x0;
780  }
781 
782  return recoParams;
783 }
784 
785 //______________________________________________________________________________
786 void
787 AliMUONRecoParam::Show(Int_t runNumber, const char* ocdb)
788 {
790 
791  AliCDBManager::Instance()->SetDefaultStorage(ocdb);
792  AliCDBManager::Instance()->SetRun(runNumber);
793 
794  AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Calib/RecoParam");
795 
796  if (!entry) return;
797 
798  TObject* o = entry->GetObject();
799 
800  if ( o->IsA() == TObjArray::Class() )
801  {
802  TObjArray* array = static_cast<TObjArray*>(o);
803  for ( Int_t i = 0; i <= array->GetLast(); ++i )
804  {
805  AliDetectorRecoParam* p = static_cast<AliDetectorRecoParam*>(array->At(i));
806  cout << Form("array[%d]=%s %s %s",i,
807  p ? p->ClassName() : "",
808  p ? AliRecoParam::GetEventSpecieName(AliRecoParam::Convert(p->GetEventSpecie())) :"",
809  p ? ( p->IsDefault() ? "default" : "") : "" ) << endl;
810  }
811  cout << "=========== dumps below ====== " << endl;
812 
813  for ( Int_t i = 0; i <= array->GetLast(); ++i )
814  {
815  AliDetectorRecoParam* p = static_cast<AliDetectorRecoParam*>(array->At(i));
816  if ( p ) p->Print("FULL");
817  }
818  }
819  else
820  {
821  o->Print();
822  }
823 }
Double32_t fMaxStripAreaForTrigger
max. search area in strips to apply on trigger track during trigger chamber efficiency ...
Double32_t fMissingPadFractionLimit
DEPRECATED.
Double32_t fMaxNonBendingDistanceToTrack
maximum distance to the track to search for compatible cluster(s) in non bending direction ...
Float_t ManuOccupancyHighLimit() const
Retrieve high value of manu occupancy limit.
Double32_t fSigmaCutForTracking
cut in sigma to apply on cluster (local chi2) and track (global chi2) during tracking ...
Int_t fBypassSt45
non-zero to use trigger tracks to generate "fake" clusters in St 4 and 5. Can be 0, 4, 5 or 45 only
Bool_t BypassSt4() const
return kTRUE if we should replace clusters in St 4 by generated clusters from trigger tracks ...
void ImproveTracks(Bool_t flag)
switch on/off the track improvement and keep the default cut in sigma to apply on cluster (local chi2...
void SetHVLimit(Int_t chamberId, Double_t ichamber)
Set HV threshold for chambers (chamberId=0..9, use -1 to set all chambers equal)
TString fTrackingMode
tracking mode: ORIGINAL, KALMAN
Double32_t fMaxBendingSlope
maximum value of the bending slope (used only if B = 0)
static AliMUONRecoParam * GetCalibrationParam()
Double32_t fDefaultNonBendingReso[10]
default chamber resolution in the non-bending direction
Double_t LowestPadCharge() const
Get the lowest charge we allow for pads.
Bool_t fCombinedClusterTrackReco
switch on/off the combined cluster/track reconstruction
#define TObjArray
UInt_t RequestedStationMask() const
return an integer where first 5 bits are set to 1 if the corresponding station is requested ...
Double_t ChargeSigmaCut() const
Number of sigma cut we must apply when cutting on adc-ped.
Bool_t fRequestStation[5]
kTRUE to request at least one cluster in station i to validate the track
Bool_t fMakeTrackCandidatesFast
kTRUE to make candidate tracks assuming linear propagation between stations 4 and 5 ...
Bool_t fTrackAllTracks
kTRUE to track all the possible candidates; kFALSE to track only the best ones
static AliMUONRecoParam * GetHighFluxParam()
Double32_t fDEOccupancyLimits[2]
low and high thresholds for DE occupancy cut
Float_t PedMeanHighLimit() const
Retrieve high limit of ped mean.
void SetPedMeanLimits(float low, float high)
Set Low and High threshold for pedestal mean.
void SetDefaultNonBendingReso(Int_t iCh, Double_t val)
Set the default non bending resolution of chamber iCh.
Float_t BuspatchOccupancyLowLimit() const
Retrieve low value of bp occupancy limit.
Bool_t BypassSt45() const
return kTRUE if we should replace clusters in St 4 and 5 by generated clusters from trigger tracks ...
void SaveFullClusterInESD(Bool_t flag, Double_t percentOfEvent=100.)
save all cluster info (including pads) in ESD, for the given percentage of events ...
Double_t AverageNoisePadCharge() const
Get the (truncated) average of sigmas of pedestal measurements, i.e. noise, of pads.
Double32_t fPedSigmaLimits[2]
Low and High threshold for pedestal sigma.
Bool_t fImproveTracks
kTRUE to try to improve the reconstructed tracks by removing bad clusters
void SetSigmaCutForTracking(Double_t val)
set the cut in sigma to apply on cluster (local chi2) and track (global chi2) during tracking ...
Class with MUON reconstruction parameters.
void DiscardMonoCathodClusters(Bool_t flag)
Discard or not the mono-cathod clusters by assigning to them different resolutions (use default value...
Float_t FractionOfBuspatchOutsideOccupancyLimit() const
Get the fraction of buspatches outside the occupancy limits.
Double32_t fDiscardMonoCathodClusters
UInt_t fPadGoodnessMask
goodness mask (see AliMUONPadStatusMaker)
static void Show(Int_t runNumber, const char *ocdbPath="raw://")
Show what is the OCDB for that run.
TObjArray * array
Definition: AnalyzeLaser.C:12
virtual Bool_t TryRecover() const
Whether or not we try to recover corrupted raw data.
static TObjArray * Create(const char *settings)
Create object ready to be put in OCDB.
Double32_t fMaxNormChi2MatchTrigger
maximum normalized chi2 of tracking/trigger track matching
Double32_t fStripCutForTrigger
cut in strips to apply on trigger track during trigger chamber efficiency
Int_t fMaxTrackCandidates
maximum number of track candidates above which the tracking abort
Bool_t fMakeMoreTrackCandidates
kTRUE to make candidate tracks starting from 1 cluster in each of the stations 4 and 5 ...
ClassImp(AliMUONRecoParam) AliMUONRecoParam
Double_t HVLimit(Int_t chamberId) const
Retrieve HV limit for chamber (chamberId=0..9)
Double32_t fHVLimit[10]
static AliMUONRecoParam * GetCosmicParam()
Double32_t fManuOccupancyLimits[2]
low and high thresholds for manu occupancy cut
void SetStripCutForTrigger(Double_t val)
set the cut in strips to apply on trigger track during trigger chamber efficiency ...
void SetBuspatchOccupancyLimits(float low, float high)
Set the limits for the acceptable bp occupancy.
TString fClusteringMode
name of the clustering (+ pre-clustering) mode
Float_t PedSigmaLowLimit() const
Retrieve low limit of ped sigma.
Double32_t fMaxBendingMomentum
maximum value (GeV/c) of momentum in bending plane
static TString AsCondition(Int_t status)
Double32_t fHVSt12Limits[2]
DEPRECATED. See fHVLimits.
Bool_t fRecoverTracks
kTRUE to try to recover the tracks getting lost during reconstruction
Bool_t BypassSt5() const
return kTRUE if we should replace clusters in St 5 by generated clusters from trigger tracks ...
virtual void SetEventSizeLimits(Double_t soft, Double_t hard)
Set the max event size limits.
static AliMUONRecoParam * GetLowFluxParam()
Double32_t fBuspatchOccupancyLimits[2]
low and high thresholds for bus patch occupancy cut
Double32_t fPercentOfFullClusterInESD
percentage of events for which all cluster info are stored in ESD
Double32_t fSigmaCutForTrigger
cut in sigma to apply on track during trigger hit pattern search
Float_t DEOccupancyLowLimit() const
Retrieve low value of DE occupancy limit.
Double32_t fNonBendingVertexDispersion
vertex dispersion (cm) in non bending plane (used for original tracking only)
Bool_t fComplementTracks
kTRUE to try to complete the reconstructed tracks by adding missing clusters
Double32_t fBendingVertexDispersion
vertex dispersion (cm) in bending plane (used for original tracking only)
void SetManuOccupancyLimits(float low, float high)
Set the limits for the acceptable manu occupancy.
Bool_t fRemoveConnectedTracksInSt12
kTRUE to remove tracks sharing cluster in station 1 and 2
void SetPadGoodnessMask(UInt_t mask)
Set the goodness mask (see AliMUONPadStatusMapMaker)
Double32_t fFractionOfBuspatchOutsideOccupancyLimit
above this limit, we consider we have too many buspatches out of the allowed occupancy range ...
void SetDefaultBendingReso(Int_t iCh, Double_t val)
Set the default bending resolution of chamber iCh.
Bool_t fSaveFullClusterInESD
kTRUE to save all cluster info (including pads) in ESD
Float_t PedMeanLowLimit() const
Retrieve low limit of ped mean.
Double32_t fEventSizeSoftLimit
(soft) limit on mean event size per event (KB)
Double32_t fMaxNonBendingSlope
maximum value of the non bending slope
Double32_t fMonoCathodClNonBendingRes
Bool_t fTryRecover
try to recover corrupted raw data
Double32_t fEventSizeHardLimit
(hard) limit on mean event size per event (KB)
Bool_t fSelectTrackOnSlope
select track candidates according to their slope (instead of their impact parameter) ...
void RequestStation(Int_t iSt, Bool_t flag)
request or not at least one cluster in the station to validate the track
Int_t fMaxTriggerTracks
maximum number of trigger tracks above which the tracking is cancelled
void SetFractionOfBuspatchOutsideOccupancyLimit(float v)
Set the fraction of buspatches outside the occupancy limits.
Double_t ClusterChargeCut() const
Get the cut applied to cut on cluster charge (the charge is cut if below fClusterChargeCut*LowestPadC...
Double32_t fMonoCathodClBendingRes
Double32_t fSigmaCutForImprovement
cut in sigma to apply on cluster (local chi2) during track improvement
Double32_t fPedMeanLimits[2]
Low and High threshold for pedestal mean.
UInt_t PadGoodnessMask() const
Get the goodness mask.
void SetSigmaCutForTrigger(Double_t val)
set the cut in sigma to apply on track during trigger hit pattern search
Float_t ManuOccupancyLowLimit() const
Retrieve low value of manu occupancy limit.
Bool_t fUseSmoother
kTRUE to use the smoother to compute track parameters/covariances and local chi2 at each cluster (use...
Double32_t fTokenLostLimit
limit on the fraction of token lost error per event we allow
Float_t PedSigmaHighLimit() const
Retrieve high limit of ped sigma.
Double32_t fMaxBendingDistanceToTrack
maximum distance to the track to search for compatible cluster(s) in bending direction ...
Float_t DEOccupancyHighLimit() const
Retrieve high value of DE occupancy limit.
void UseChamber(Int_t iCh, Bool_t flag)
switch on/off a chamber in the reconstruction
virtual void SetTokenLostLimit(Double_t limit)
Set the percentage of token lost error we allow.
Bool_t fUseChamber[10]
kTRUE to use the chamber i in the tracking algorithm
Float_t BuspatchOccupancyHighLimit() const
Retrieve high value of bp occupancy limit.
Double32_t fMinBendingMomentum
minimum value (GeV/c) of momentum in bending plane
Double32_t fHVSt345Limits[2]
DEPRECATED. See fHVLimits.
Double32_t fDefaultBendingReso[10]
default chamber resolution in the bending direction
virtual void Print(Option_t *option="") const