Make the Scan method public
[u/mrichter/AliRoot.git] / MUON / AliMUONRecoParam.cxx
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 //-----------------------------------------------------------------------------
19 /// \class AliMUONRecoParam
20 ///
21 /// Class with MUON reconstruction parameters
22 ///
23 ///  \author Philippe Pillot
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;
41 ClassImp(AliMUONRecoParam)
42
43
44 //_____________________________________________________________________________
45 AliMUONRecoParam::AliMUONRecoParam()
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   fCalibrationMode("NOGAIN"),
74   fBypassSt45(0),
75   fPadGoodnessMask(0),
76   fChargeSigmaCut(4.0),
77   fRemoveConnectedTracksInSt12(kFALSE),
78   fMaxTriggerTracks(0),
79   fMaxTrackCandidates(0),
80   fSelectTrackOnSlope(kFALSE),
81   fMissingPadFractionLimit(-1),
82   fFractionOfBuspatchOutsideOccupancyLimit(0),
83   fAverageNoisePadCharge(0.22875),
84   fClusterChargeCut(2.0),
85   fEventSizeSoftLimit(35.0),
86   fEventSizeHardLimit(45.0),
87   fTokenLostLimit(0.0),
88   fTryRecover(kFALSE)
89 {  
90   /// Constructor
91   
92   SetNameTitle("Dummy","Dummy");
93   for (Int_t iCh = 0; iCh < 10; iCh++) {
94     fUseChamber[iCh] = kTRUE;
95     fDefaultNonBendingReso[iCh] = 0.;
96     fDefaultBendingReso[iCh] = 0.;
97   }
98   for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
99   SetDefaultLimits();
100 }
101
102 //_____________________________________________________________________________
103 AliMUONRecoParam::~AliMUONRecoParam() 
104 {
105   /// Destructor
106 }
107
108 //_____________________________________________________________________________
109 void
110 AliMUONRecoParam::BypassSt45(Bool_t st4, Bool_t st5)
111 {
112         /// Set the bypass status
113         
114         if ( st4 && st5 ) fBypassSt45 = 45;
115         else if ( st4 ) fBypassSt45 = 4;
116         else if ( st5 ) fBypassSt45 = 5;
117         else fBypassSt45 = 0;
118 }
119
120 //_____________________________________________________________________________
121 Option_t*
122 AliMUONRecoParam::GetCalibrationMode() const
123 {
124   /// Return the calibration mode. Can be : 
125   /// NOGAIN : only do pedestal subtraction
126   /// GAIN : do pedestal subtraction, and apply gain correction, but with a
127   ///        single capacitance value for all channels
128   /// INJECTIONGAIN : as GAIN, but with gain values taken as EMELEC factory values
129   /// GAINCONSTANTCAPA : as GAIN, but with a channel-dependent capacitance value
130   
131   return fCalibrationMode.Data();
132 }
133
134 //_____________________________________________________________________________
135 AliMUONRecoParam *AliMUONRecoParam::GetLowFluxParam() 
136 {
137   /// Return default reconstruction parameters for low flux environment
138   
139   AliMUONRecoParam *param = new AliMUONRecoParam();
140   param->SetLowFluxParam();
141   
142   return param;
143 }
144
145 //_____________________________________________________________________________
146 AliMUONRecoParam *AliMUONRecoParam::GetHighFluxParam() 
147 {
148   /// Return default reconstruction parameters for high flux environment
149   
150   AliMUONRecoParam *param = new AliMUONRecoParam();
151   param->SetHighFluxParam();
152  
153   return param;
154 }
155
156 //_____________________________________________________________________________
157 AliMUONRecoParam *AliMUONRecoParam::GetCosmicParam() 
158 {
159   /// Return default reconstruction parameters for high flux environment
160   
161   AliMUONRecoParam *param = new AliMUONRecoParam();
162   param->SetCosmicParam();
163   
164   return param;
165 }
166
167 //_____________________________________________________________________________
168 AliMUONRecoParam *AliMUONRecoParam::GetCalibrationParam() 
169 {
170   /// Return default (dummy) reconstruction parameters for calibration environment
171   
172   AliMUONRecoParam *param = new AliMUONRecoParam();
173   param->SetCalibrationParam();
174   
175   return param;
176 }
177
178
179 //_____________________________________________________________________________
180 void AliMUONRecoParam::SetLowFluxParam() 
181 {
182   /// Set reconstruction parameters for low flux environment
183   
184   SetNameTitle("Low Flux","Low Flux");
185   SetEventSpecie(AliRecoParam::kLowMult);
186   fMinBendingMomentum = 0.8;
187   fMaxBendingMomentum = 1.e10;
188   fMaxNonBendingSlope = 0.3;
189   fMaxBendingSlope = 0.4;
190   fSelectTrackOnSlope = kFALSE;
191   fNonBendingVertexDispersion = 70.;
192   fBendingVertexDispersion = 70.;
193   fMaxNonBendingDistanceToTrack = 1.;
194   fMaxBendingDistanceToTrack = 1.;
195   fSigmaCutForTracking = 6.;
196   fSigmaCutForImprovement = 5.;
197   fSigmaCutForTrigger = 4.;
198   fStripCutForTrigger = 1.;
199   fMaxStripAreaForTrigger = 3.;
200   fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger;
201   fCombinedClusterTrackReco = kFALSE;
202   fTrackAllTracks = kTRUE;
203   fRecoverTracks = kTRUE;
204   fMakeTrackCandidatesFast = kFALSE;
205   fMakeMoreTrackCandidates = kFALSE;
206   fComplementTracks = kTRUE;
207   fImproveTracks = kTRUE;
208   fRemoveConnectedTracksInSt12 = kFALSE;
209   fUseSmoother = kTRUE;
210   for (Int_t iCh = 0; iCh < 10; iCh++) {
211     fUseChamber[iCh] = kTRUE;
212     fDefaultNonBendingReso[iCh] = 0.144;
213     fDefaultBendingReso[iCh] = 0.01;
214   }
215   for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
216   fBypassSt45 = 0;
217   fMaxTriggerTracks = 100;
218   fMaxTrackCandidates = 10000;  
219 }
220
221 //_____________________________________________________________________________
222 void AliMUONRecoParam::SetHighFluxParam() 
223 {
224   /// Set reconstruction parameters for high flux environment
225   
226   SetNameTitle("High Flux","High Flux");
227   SetEventSpecie(AliRecoParam::kHighMult);
228   fMinBendingMomentum = 0.8;
229   fMaxBendingMomentum = 1.e10;
230   fMaxNonBendingSlope = 0.3;
231   fMaxBendingSlope = 0.4;
232   fSelectTrackOnSlope = kFALSE;
233   fNonBendingVertexDispersion = 70.;
234   fBendingVertexDispersion = 70.;
235   fMaxNonBendingDistanceToTrack = 1.;
236   fMaxBendingDistanceToTrack = 1.;
237   fSigmaCutForTracking = 6.;
238   fSigmaCutForImprovement = 5.;
239   fSigmaCutForTrigger = 4.;
240   fStripCutForTrigger = 1.;
241   fMaxStripAreaForTrigger = 3.;
242   fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger;
243   fCombinedClusterTrackReco = kFALSE;
244   fTrackAllTracks = kTRUE;
245   fRecoverTracks = kTRUE;
246   fMakeTrackCandidatesFast = kFALSE;
247   fMakeMoreTrackCandidates = kFALSE;
248   fComplementTracks = kTRUE;
249   fImproveTracks = kTRUE;
250   fRemoveConnectedTracksInSt12 = kFALSE;
251   fUseSmoother = kTRUE;
252   for (Int_t iCh = 0; iCh < 10; iCh++) {
253     fUseChamber[iCh] = kTRUE;
254     fDefaultNonBendingReso[iCh] = 0.144;
255     fDefaultBendingReso[iCh] = 0.01;
256   }
257   for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
258   fBypassSt45 = 0;
259   fMaxTriggerTracks = 100;
260   fMaxTrackCandidates = 10000;
261 }
262
263 //_____________________________________________________________________________
264 void AliMUONRecoParam::SetCosmicParam() 
265 {
266   /// Set reconstruction parameters for high flux environment
267   
268   SetNameTitle("Cosmic","Cosmic");
269   SetEventSpecie(AliRecoParam::kCosmic);
270   fMinBendingMomentum = 0.8;
271   fMaxBendingMomentum = 1.e10;
272   fMaxNonBendingSlope = 0.3;
273   fMaxBendingSlope = 0.4;
274   fSelectTrackOnSlope = kTRUE;
275   fNonBendingVertexDispersion = 170.;
276   fBendingVertexDispersion = 170.;
277   fMaxNonBendingDistanceToTrack = 1.;
278   fMaxBendingDistanceToTrack = 1.;
279   fSigmaCutForTracking = 7.;
280   fSigmaCutForImprovement = 6.;
281   fSigmaCutForTrigger = 4.;
282   fStripCutForTrigger = 1.5;
283   fMaxStripAreaForTrigger = 3.;
284   fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger;
285   fPercentOfFullClusterInESD = 100.;
286   fCombinedClusterTrackReco = kFALSE;
287   fTrackAllTracks = kTRUE;
288   fRecoverTracks = kTRUE;
289   fMakeTrackCandidatesFast = kFALSE;
290   fMakeMoreTrackCandidates = kFALSE;
291   fComplementTracks = kTRUE;
292   fImproveTracks = kTRUE;
293   fRemoveConnectedTracksInSt12 = kTRUE;
294   fUseSmoother = kTRUE;
295   fSaveFullClusterInESD = kTRUE;
296   for (Int_t iCh = 0; iCh < 10; iCh++) {
297     fUseChamber[iCh] = kTRUE;
298     fDefaultNonBendingReso[iCh] = 0.4;
299     fDefaultBendingReso[iCh] = 0.4;
300   }
301   fRequestStation[0] = kTRUE;
302   fRequestStation[1] = kTRUE;
303   fRequestStation[2] = kTRUE;
304   fRequestStation[3] = kTRUE;
305   fRequestStation[4] = kTRUE;
306   fBypassSt45 = 0;
307   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
308   fMaxTriggerTracks = 100;
309   fMaxTrackCandidates = 10000;
310   
311   SetPedMeanLimits(20, 700);
312   SetManuOccupancyLimits(-1.,0.01); // reject manu above occ=1%
313
314   SetBuspatchOccupancyLimits(-1,0.05);  
315   SetFractionOfBuspatchOutsideOccupancyLimit(0.10); // 10 %
316 }
317
318
319 //_____________________________________________________________________________
320 void AliMUONRecoParam::SetCalibrationParam() 
321 {
322   /// Set (dummy) reconstruction parameters for calibration environment
323   
324   SetNameTitle("Calibration","Calibration");
325   SetEventSpecie(AliRecoParam::kCalib);
326
327   fPedMeanLimits[0] = 5000;
328   fPedMeanLimits[1] = 0;
329
330   fPadGoodnessMask = 0x8C00; // Pedestal is missing | is too low | too high
331
332 }
333
334 //_____________________________________________________________________________
335 UInt_t
336 AliMUONRecoParam::RequestedStationMask() const
337 {
338   /// Get the mask of the requested station, i.e. an integer where 
339   /// bit n is set to one if the station n was requested
340   
341   UInt_t m(0);
342   
343   for ( Int_t i = 0; i < 5; ++i ) 
344   {
345     if ( RequestStation(i) ) m |= ( 1 << i );
346   }
347   return m;
348 }
349
350 //_____________________________________________________________________________
351 void AliMUONRecoParam::Print(Option_t *option) const
352 {
353   /// print reconstruction parameters
354   /// if option = FULL then print also unused parameters
355   
356   cout<<endl<<"\t------MUON Reconstruction parameters ("<<GetName()<<")------"<<endl;
357   
358   if (IsDefault()) cout<<"\t\t*** Parameters used by default ***"<<endl;
359   
360   cout << "Event Specie=" << GetEventSpecie() << endl;
361   
362   cout<<Form("Calibration mode = %s",fCalibrationMode.Data())<<endl;
363   cout<<Form("Clustering mode = %s",fClusteringMode.Data())<<endl;
364   cout<<Form("Tracking mode = %s",fTrackingMode.Data())<<endl;
365
366         TString bypass;
367         
368         if ( BypassSt45() )
369         {
370                 bypass = "stations 4 and 5";
371         }
372         else if ( BypassSt4() ) 
373         {
374                 bypass = "station 4";
375         }
376         else if ( BypassSt5() ) 
377         {
378                 bypass = "station 5";
379         }
380         
381   if (bypass.Length()) cout << "Will bypass " << bypass.Data() << " (replacing real clusters by generated ones from trigger tracks)" << endl;
382   
383   if (fCombinedClusterTrackReco) cout<<"Combined cluster/track reconstruction: ON"<<endl;
384   else cout<<"Combined cluster/track reconstruction: OFF"<<endl;
385   
386   if (fSaveFullClusterInESD) cout<<Form("Save all cluster info in ESD for %5.2f %% of events",fPercentOfFullClusterInESD)<<endl;
387   else cout<<"Save partial cluster info in ESD"<<endl;
388     
389   cout<<"Selection of track candidates:"<<endl;
390   if (fSelectTrackOnSlope) cout<<Form("\t- Non-bending slope < %5.2f",fMaxNonBendingSlope)<<endl;
391   else cout<<"\t- Impact parameter < 3 * vertex dispersion in the non-bending direction"<<endl;
392   cout<<Form("\t- if B!=0: Bending momentum > %5.2f",fMinBendingMomentum)<<endl;
393   if (fSelectTrackOnSlope) cout<<Form("\t  if B==0: Bending slope < %5.2f",fMaxBendingSlope)<<endl;
394   else cout<<"\t  if B==0: Impact parameter < 3 * vertex dispersion in the bending direction"<<endl;
395   
396   cout<<Form("Vertex dispersion (used to estimate initial bending momentum resolution) = (%5.2f,%5.2f)",fNonBendingVertexDispersion,fBendingVertexDispersion)<<endl;
397   
398   cout<<Form("Maximum distance to track = (%5.2f,%5.2f)",fMaxNonBendingDistanceToTrack,fMaxBendingDistanceToTrack)<<endl;
399   
400   cout<<Form("Sigma cut for tracking = %5.2f",fSigmaCutForTracking)<<endl;
401
402   cout<<Form("Sigma cut for trigger hit pattern = %5.2f",fSigmaCutForTrigger)<<endl;
403
404   cout<<Form("Cut in strips for trigger chamber efficiency = %5.2f",fStripCutForTrigger)<<endl;
405
406   cout<<Form("Max search area in strips for trigger chamber efficiency = %5.2f",fMaxStripAreaForTrigger)<<endl;
407
408   if (fTrackAllTracks) cout<<"Track all the possible candidates"<<endl;
409   else cout<<"Track only the best candidates"<<endl;
410   
411   if (strstr(option,"FULL")) {
412     cout<<"Make track candidates assuming linear propagation between stations 4 and 5: ";
413     if (fMakeTrackCandidatesFast) cout<<"ON"<<endl;
414     else cout<<"OFF"<<endl;
415   } else if (fMakeTrackCandidatesFast)
416     cout<<"Make track candidates assuming linear propagation between stations 4 and 5"<<endl;
417   
418   if (strstr(option,"FULL")) {
419     cout<<"Make track candidates starting from 1 cluster in each of the stations 4 and 5: ";
420     if (fMakeMoreTrackCandidates) cout<<"ON"<<endl;
421     else cout<<"OFF"<<endl;
422   } else if (fMakeMoreTrackCandidates)
423     cout<<"Make track candidates starting from 1 cluster in each of the stations 4 and 5"<<endl;
424   
425   if (strstr(option,"FULL")) {
426     cout<<"Try to recover tracks getting lost during tracking: ";
427     if (fRecoverTracks) cout<<"ON"<<endl;
428     else cout<<"OFF"<<endl;
429   } else if (fRecoverTracks)
430     cout<<"Try to recover tracks getting lost during tracking"<<endl;
431   
432   if (strstr(option,"FULL")) {
433     cout<<"Try to complete the reconstructed tracks by adding missing clusters: ";
434     if (fComplementTracks) cout<<"ON"<<endl;
435     else cout<<"OFF"<<endl;
436   } else if (fComplementTracks)
437     cout<<"Try to complete the reconstructed tracks by adding missing clusters"<<endl;
438   
439   if (strstr(option,"FULL")) {
440     cout<<"Try to improve the reconstructed tracks by removing bad clusters: ";
441     if (fImproveTracks) cout<<Form("ON (sigma cut = %5.2f)",fSigmaCutForImprovement)<<endl;
442     else cout<<"OFF"<<endl;
443   } else if (fImproveTracks)
444     cout<<Form("Try to improve the reconstructed tracks by removing bad clusters (sigma cut = %5.2f)",fSigmaCutForImprovement)<<endl;
445   
446   if (fRemoveConnectedTracksInSt12) cout<<"Remove tracks sharing one cluster or more in any station"<<endl;
447   else cout<<"Remove tracks sharing one cluster or more in stations 3, 4 and 5"<<endl;
448   
449   if (strstr(option,"FULL")) {
450     cout<<"Use smoother to compute final track parameters, etc, at each cluster (used for Kalman tracking only): ";
451     if (fUseSmoother) cout<<"ON"<<endl;
452     else cout<<"OFF"<<endl;
453   } else if (fUseSmoother)
454     cout<<"Use smoother to compute final track parameters, etc, at each cluster"<<endl;
455   
456   cout<<Form("Maximum normalized chi2 of tracking/trigger track matching = %5.2f",fMaxNormChi2MatchTrigger)<<endl;
457   
458   Bool_t discardedCh = kFALSE;
459   Int_t ch = 0;
460   do {
461     if (!UseChamber(ch)) {
462       if (!discardedCh) {
463         cout<<"Discarded chambers(1..): "<<ch+1;
464         discardedCh = kTRUE;
465       }
466       else cout<<" "<<ch+1;
467     }
468   } while (++ch < 10);
469   if (discardedCh) cout<<endl;
470   
471   Bool_t discardedSt = kFALSE;
472   Int_t st = 0;
473   do {
474     if (!RequestStation(st)) {
475       if (!discardedSt) {
476         cout<<"Not requested stations(1..): "<<st+1;
477         discardedSt = kTRUE;
478       }
479       else cout<<" "<<st+1;
480     }
481   } while (++st < 5);
482   if (discardedSt) cout<<endl;
483   
484   cout << Form("Pad goodness policy mask is 0x%x",PadGoodnessMask()) << endl;
485   cout << "Which means we reject pads having the condition = " <<
486   AliMUONPadStatusMaker::AsCondition(PadGoodnessMask()).Data() << endl;
487   
488   cout << "The pad limits we are using are :" << endl;
489   
490   for ( int ichamber = 0; ichamber < 10; ++ichamber ) 
491   {
492     cout << Form("HV Ch %d must be >= %5.2f",ichamber,HVLimit(ichamber)) << endl;
493   }
494
495   cout << Form("%7.2f <= Pedestal mean <= %7.2f",PedMeanLowLimit(),PedMeanHighLimit()) << endl;
496   cout << Form("%7.2f <= Pedestal sigma <= %7.2f",PedSigmaLowLimit(),PedSigmaHighLimit()) << endl;
497   cout << Form("%e <= Gain linear term <= %e",GainA1LowLimit(),GainA1HighLimit()) << endl;
498   cout << Form("%e <= Gain quadratic term <= %e",GainA2LowLimit(),GainA2HighLimit()) << endl;
499   cout << Form("%5.0f <= Gain threshold term <= %5.0f",GainThresLowLimit(),GainThresHighLimit()) << endl;
500     
501   cout << Form("And we cut on charge >= %7.2f x ( pedestal sigma ) ",ChargeSigmaCut()) << endl;
502   
503   cout << "Occupancy limits are :" << endl;
504   
505   cout << Form("%e <= Manu occupancy < %7.3f",ManuOccupancyLowLimit(),ManuOccupancyHighLimit()) << endl;
506   cout << Form("%e <= Buspatch occupancy < %7.3f",BuspatchOccupancyLowLimit(),BuspatchOccupancyHighLimit()) << endl;
507   cout << Form("%e <= DE occupancy < %7.3f",DEOccupancyLowLimit(),DEOccupancyHighLimit()) << endl;
508   
509   cout << "'QAChecker' limits" << endl;  
510   cout << Form("FractionOfBuspatchOutsideOccupancyLimit = %5.2f %%",FractionOfBuspatchOutsideOccupancyLimit()*100.0) << endl;
511   cout << Form("Event size limit = %5.2f KB/event (soft) and %5.2f KB/event (hard)",fEventSizeSoftLimit,fEventSizeHardLimit) << endl;
512   if ( fTokenLostLimit > 0 )
513   {
514     cout << Form("We tolerate up to %5.2f %% token lost errors per event",fTokenLostLimit) << endl;
515   }
516   else
517   {
518     cout << "We dot not tolerate any token lost error !" << endl;
519   }
520   
521   cout << "chamber non bending resolution = |";
522   for (Int_t iCh = 0; iCh < 10; iCh++) cout << Form(" %6.3f |",fDefaultNonBendingReso[iCh]);
523   cout << endl;
524   cout << "chamber bending resolution = |";
525   for (Int_t iCh = 0; iCh < 10; iCh++) cout << Form(" %6.3f |",fDefaultBendingReso[iCh]);
526   cout << endl;
527   cout<<Form("maximum number of trigger tracks above which the tracking is cancelled = %d",fMaxTriggerTracks)<<endl;
528   cout<<Form("maximum number of track candidates above which the tracking is abandonned = %d",fMaxTrackCandidates)<<endl;
529
530   cout << Form("The average noise pad charge is assumed to be %7.2f fC",AverageNoisePadCharge()) << endl;
531   cout << Form("and clusters below %5.2f times this noise charge (i.e. %7.2f fC) are discarded",
532                ClusterChargeCut(),ClusterChargeCut()*AverageNoisePadCharge()) << endl;
533   cout << Form("Note that LowestPadCharge is then %7.2f fC",LowestPadCharge()) << endl;
534   
535   if (TryRecover())
536   {
537     cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;
538     cout << "!!! WILL TRY TO RECOVER CORRUPTED RAW DATA !!!" << endl;
539     cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;    
540   }
541   cout<<"\t-----------------------------------------------------"<<endl<<endl;
542   
543 }
544
545 //_____________________________________________________________________________
546 void
547 AliMUONRecoParam::SetHVLimit(Int_t chamberId, Double_t value)
548 {
549   /// Set the HV limit for a given chamber (or all chambers 
550   /// if chamberId==-1
551   
552   if ( chamberId == -1 ) 
553   {
554     for ( Int_t i = 0; i < 10; ++i ) 
555     {
556       fHVLimit[i] = value;
557     }
558   }
559   else if ( chamberId >= 0 && chamberId < 10 ) 
560   {
561     fHVLimit[chamberId]=value;
562   }
563   else
564   {
565     AliError(Form("chamberId = %d is not a valid chamberId",chamberId));
566   }
567 }
568
569 //_____________________________________________________________________________
570 Double_t AliMUONRecoParam::HVLimit(Int_t chamberId) const
571 {
572   /// Get the HV limit for a given chamber
573   if ( chamberId >= 0 && chamberId < 10 )
574   {
575     return fHVLimit[chamberId];
576   }
577   AliError(Form("chamberId = %d is not a valid chamberId",chamberId));
578
579   return 0.0;
580 }
581
582 //_____________________________________________________________________________
583 void
584 AliMUONRecoParam::SetDefaultLimits()
585 {
586         /// Set the default limits and pad goodness policy
587
588   fHVSt12Limits[0]=1500; // kept for backward compatibility only
589         fHVSt12Limits[1]=2000; // kept for backward compatibility only
590         fHVSt345Limits[0]=1500; // kept for backward compatibility only
591         fHVSt345Limits[1]=2000; // kept for backward compatibility only
592   
593   SetHVLimit(-1,1590); // this one is the real HV limit used now
594   
595         fPedMeanLimits[0] = 20;
596         fPedMeanLimits[1] = 1024;
597         
598         fPedSigmaLimits[0] = 0.6;
599         fPedSigmaLimits[1] = 100;
600
601         fGainA1Limits[0] = 0.1;
602         fGainA1Limits[1] = 10;
603
604         fGainA2Limits[0] = -1E30;
605         fGainA2Limits[1] = 1E30;
606         
607         fGainThresLimits[0] = 0;
608         fGainThresLimits[1] = 4095;
609         
610         fPadGoodnessMask = 0x8080; // Ped is missing | HV is missing
611
612   fManuOccupancyLimits[0] = -1.0; 
613   fManuOccupancyLimits[1] = 1.0;
614
615   fBuspatchOccupancyLimits[0] = 1E-6; 
616   fBuspatchOccupancyLimits[1] = 1.0;
617
618   fDEOccupancyLimits[0] = -1.0; 
619   fDEOccupancyLimits[1] = 1.0;
620
621   fMissingPadFractionLimit = -1; // DEPRECATED
622   fFractionOfBuspatchOutsideOccupancyLimit = 0.05; // 5 % 
623
624   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)
625   
626   AverageNoisePadCharge(0.22875); // 0.22875 coulombs ~ 1.5 ADC channels
627
628   ClusterChargeCut(2.0); // will cut cluster below 2.0 x LowestPadCharge()
629   
630   SetEventSizeLimits(35.0,45.0);
631   
632   SetTokenLostLimit(0.0);
633   
634   fTryRecover = kFALSE;
635 }
636
637
638 //-----------------------------------------------------------------------
639 TObjArray* 
640 AliMUONRecoParam::Create(const char* settings)
641 {
642   /// Create pre-defined recoparam array, according to settings.
643   /// settings is case-insensitive.
644   ///
645   /// Currently defined are :
646   ///
647   /// "cosmics" :
648   ///      Cosmic (default)
649   ///      Calibration
650   /// "ppideal"
651   ///      LowFlux (default)
652   ///      Calibration
653   /// "ppreal"
654   ///      LowFlux (modified to reconstruct real p-p data)
655   ///      Calibration
656   /// "pprealsim"
657   ///      LowFlux (modified to reconstruct realistic p-p simulation)
658   ///      Calibration
659   /// "pbpbreal"
660   ///      HighFlux (modified to reconstruct real Pb-Pb data)
661   ///      Calibration
662   
663   AliMUONRecoParam* param(0x0);
664   
665   AliRecoParam::EventSpecie_t defaultParam = AliRecoParam::kLowMult;
666   
667   TString stype(settings);
668   stype.ToLower();
669   
670   if ( stype == "cosmics" )
671   {
672     // set parameters for cosmic runs
673     param = AliMUONRecoParam::GetCosmicParam();
674     defaultParam = AliRecoParam::kCosmic;
675   }
676   else if ( stype == "ppideal" ) 
677   {
678     // set default lowFlux parameters
679     param = AliMUONRecoParam::GetLowFluxParam();
680   }
681   else if ( stype == "ppreal" || stype == "pprealsim" || stype == "pprealnofield" ) 
682   {      
683     // common parameters for p-p data and realistic p-p simu
684     param = AliMUONRecoParam::GetLowFluxParam();
685     param->SaveFullClusterInESD(kTRUE, 100.);
686     for (Int_t iCh=0; iCh<10; iCh++) 
687     {
688       param->SetDefaultNonBendingReso(iCh,0.4);
689       param->SetDefaultBendingReso(iCh,0.4);
690     }
691     param->SetSigmaCutForTracking(7.);
692     param->SetStripCutForTrigger(1.5);
693     param->SetSigmaCutForTrigger(6.);
694     param->ImproveTracks(kTRUE, 6.);
695     param->SetPedMeanLimits(20, 700);
696     param->SetManuOccupancyLimits(-1.,0.015);
697     param->SetBuspatchOccupancyLimits(-1.,0.05);  
698     param->SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 %
699     param->SetEventSizeLimits(45., 65.);
700     param->SetHVLimit(0,1550);
701     param->SetHVLimit(1,1550);
702     param->SetHVLimit(2,1550);
703     param->SetHVLimit(3,1550);
704     
705     // specific parameters for p-p data or realistic p-p simu
706     if ( stype == "ppreal" || stype == "pprealnofield" )
707     {
708       param->SetPadGoodnessMask(0x400BE9B);
709     }
710     else
711     {
712       param->SetPadGoodnessMask(0x8080);      
713     }
714     
715     if ( stype == "pprealnofield" )
716     {
717       param->TryRecover(kTRUE);
718     }
719   }
720   else if ( stype == "pbpbreal" || stype == "pbpbrealsim" ) 
721   {      
722     // common parameters for Pb-Pb data and realistic Pb-Pb simu
723     param = AliMUONRecoParam::GetHighFluxParam();
724     defaultParam = AliRecoParam::kHighMult;
725     param->SaveFullClusterInESD(kTRUE, 100.);
726     for (Int_t iCh=0; iCh<10; iCh++) 
727     {
728       param->SetDefaultNonBendingReso(iCh,0.2);
729       param->SetDefaultBendingReso(iCh,0.2);
730     }
731     param->SetSigmaCutForTracking(5.);
732     param->SetStripCutForTrigger(1.5);
733     param->SetSigmaCutForTrigger(4.);
734     param->ImproveTracks(kTRUE, 4.);
735     param->SetPedMeanLimits(20, 700);
736     param->SetManuOccupancyLimits(-1.,0.03);
737     param->SetBuspatchOccupancyLimits(-1.,0.1); // 10 % (this cut not used for the reco anyway)
738     param->SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 %
739     param->SetEventSizeLimits(100., 150.);
740     
741     // specific parameters for Pb-Pb data or realistic Pb-Pb simu
742     if ( stype == "pbpbreal" )
743     {
744       param->SetPadGoodnessMask(0x400BE9B);
745     }
746     else
747     {
748       param->SetPadGoodnessMask(0x8080);      
749     }
750   }
751   else
752   {
753     AliErrorClass("Unknown settings !");
754     return 0x0;
755   }
756
757   TObjArray* recoParams = new TObjArray;
758
759   recoParams->AddLast(param);
760   
761   // set (dummy) parameters for calibration runs
762   param = AliMUONRecoParam::GetCalibrationParam();
763   recoParams->AddLast(param);
764   
765   // set parameters for Pb-Pb runs
766   // param = AliMUONRecoParam::GetHighFluxParam();
767   // recoParams.AddLast(param);
768   
769   // identify default parameters (exit if identification failed)
770   Bool_t defaultIsSet = kFALSE;
771   TIter next(recoParams);
772   while ( (param = static_cast<AliMUONRecoParam*>(next())) ) 
773   {
774     if (param->GetEventSpecie() == defaultParam) 
775     {
776       param->SetAsDefault();
777       defaultIsSet = kTRUE;
778     }
779     param->Print("FULL");
780   }
781   
782   if (!defaultIsSet) 
783   {
784     AliErrorClass("The default reconstruction parameters are not set! Exiting...");
785     return 0x0;
786   }  
787   
788   return recoParams;
789 }
790
791 //______________________________________________________________________________
792 void 
793 AliMUONRecoParam::Show(Int_t runNumber, const char* ocdb)
794 {
795   /// Show what we have in the designated OCDB for that run, as far as RecoParams are concerned
796   
797   AliCDBManager::Instance()->SetDefaultStorage(ocdb);
798   AliCDBManager::Instance()->SetRun(runNumber);
799   
800   AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Calib/RecoParam");
801   
802   if (!entry) return;
803   
804   TObject* o = entry->GetObject();
805   
806   if ( o->IsA() == TObjArray::Class() ) 
807   {
808     TObjArray* array = static_cast<TObjArray*>(o);
809     for ( Int_t i = 0; i <= array->GetLast(); ++i ) 
810     {
811       AliDetectorRecoParam* p = static_cast<AliDetectorRecoParam*>(array->At(i));
812       cout << Form("array[%d]=%s %s %s",i,
813                    p ? p->ClassName() : "",
814                    p ? AliRecoParam::GetEventSpecieName(AliRecoParam::Convert(p->GetEventSpecie())) :"",
815                    p ? ( p->IsDefault() ? "default" : "") : "" ) << endl;
816     }
817     cout << "=========== dumps below ====== " << endl;
818     
819     for ( Int_t i = 0; i <= array->GetLast(); ++i ) 
820     {
821       AliDetectorRecoParam* p = static_cast<AliDetectorRecoParam*>(array->At(i));
822       if ( p ) p->Print("");
823     }
824   }
825   else
826   {
827     o->Print();
828   }
829 }