]>
Commit | Line | Data |
---|---|---|
3304fa09 | 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 | ||
bf4d93eb | 16 | // $Id$ |
3304fa09 | 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" | |
ad3c6eda | 29 | #include "AliMUONPadStatusMaker.h" |
3304fa09 | 30 | |
ad3c6eda | 31 | #include "AliRecoParam.h" |
3304fa09 | 32 | #include "AliLog.h" |
33 | ||
9074a9a9 | 34 | #include "AliCDBManager.h" |
35 | #include "AliCDBEntry.h" | |
36 | ||
3304fa09 | 37 | #include <Riostream.h> |
38 | ||
39 | ClassImp(AliMUONRecoParam) | |
40 | ||
41 | ||
42 | //_____________________________________________________________________________ | |
43 | AliMUONRecoParam::AliMUONRecoParam() | |
15d30ed4 | 44 | : AliDetectorRecoParam(), |
3304fa09 | 45 | fClusteringMode("MLEM"), |
46 | fTrackingMode("KALMAN"), | |
47 | fMinBendingMomentum(0.), | |
48 | fMaxBendingMomentum(0.), | |
9bf6860b | 49 | fMaxNonBendingSlope(0.), |
9f093251 | 50 | fMaxBendingSlope(0.), |
3304fa09 | 51 | fNonBendingVertexDispersion(0.), |
52 | fBendingVertexDispersion(0.), | |
53 | fMaxNonBendingDistanceToTrack(0.), | |
54 | fMaxBendingDistanceToTrack(0.), | |
55 | fSigmaCutForTracking(0.), | |
56 | fSigmaCutForImprovement(0.), | |
fda59e58 | 57 | fSigmaCutForTrigger(0.), |
b5270f21 | 58 | fStripCutForTrigger(0.), |
59 | fMaxStripAreaForTrigger(0.), | |
3304fa09 | 60 | fMaxNormChi2MatchTrigger(0.), |
0a18ba02 | 61 | fPercentOfFullClusterInESD(10.), |
38bcf0ef | 62 | fCombinedClusterTrackReco(kFALSE), |
3304fa09 | 63 | fTrackAllTracks(kFALSE), |
64 | fRecoverTracks(kFALSE), | |
65 | fMakeTrackCandidatesFast(kFALSE), | |
9bf6860b | 66 | fMakeMoreTrackCandidates(kFALSE), |
3304fa09 | 67 | fComplementTracks(kFALSE), |
68 | fImproveTracks(kFALSE), | |
0a18ba02 | 69 | fUseSmoother(kFALSE), |
de98fdc9 | 70 | fSaveFullClusterInESD(kTRUE), |
9bf6860b | 71 | fCalibrationMode("NOGAIN"), |
004a9ccd | 72 | fBypassSt45(0), |
170f4046 | 73 | fPadGoodnessMask(0), |
c59f70b9 | 74 | fChargeSigmaCut(4.0), |
89c8d66d | 75 | fRemoveConnectedTracksInSt12(kFALSE), |
76 | fMaxTriggerTracks(0), | |
6b191dea | 77 | fMaxTrackCandidates(0), |
ece56eb9 | 78 | fSelectTrackOnSlope(kFALSE), |
b3d57767 | 79 | fMissingPadFractionLimit(-1), |
110edb51 | 80 | fFractionOfBuspatchOutsideOccupancyLimit(0), |
81 | fAverageNoisePadCharge(0.22875), | |
b3d57767 | 82 | fClusterChargeCut(2.0), |
83 | fEventSizeSoftLimit(35.0), | |
84 | fEventSizeHardLimit(45.0), | |
9074a9a9 | 85 | fTokenLostLimit(0.0), |
86 | fTryRecover(kFALSE) | |
110edb51 | 87 | { |
3304fa09 | 88 | /// Constructor |
89 | ||
ad3c6eda | 90 | SetNameTitle("Dummy","Dummy"); |
c6e702f8 | 91 | for (Int_t iCh = 0; iCh < 10; iCh++) { |
92 | fUseChamber[iCh] = kTRUE; | |
93 | fDefaultNonBendingReso[iCh] = 0.; | |
94 | fDefaultBendingReso[iCh] = 0.; | |
95 | } | |
96 | for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE; | |
ad3c6eda | 97 | SetDefaultLimits(); |
3304fa09 | 98 | } |
99 | ||
100 | //_____________________________________________________________________________ | |
101 | AliMUONRecoParam::~AliMUONRecoParam() | |
102 | { | |
103 | /// Destructor | |
104 | } | |
105 | ||
004a9ccd | 106 | //_____________________________________________________________________________ |
107 | void | |
108 | AliMUONRecoParam::BypassSt45(Bool_t st4, Bool_t st5) | |
109 | { | |
110 | /// Set the bypass status | |
111 | ||
112 | if ( st4 && st5 ) fBypassSt45 = 45; | |
113 | else if ( st4 ) fBypassSt45 = 4; | |
114 | else if ( st5 ) fBypassSt45 = 5; | |
115 | else fBypassSt45 = 0; | |
116 | } | |
117 | ||
9bf6860b | 118 | //_____________________________________________________________________________ |
119 | Option_t* | |
120 | AliMUONRecoParam::GetCalibrationMode() const | |
121 | { | |
122 | /// Return the calibration mode. Can be : | |
123 | /// NOGAIN : only do pedestal subtraction | |
124 | /// GAIN : do pedestal subtraction, and apply gain correction, but with a | |
125 | /// single capacitance value for all channels | |
66cdf5b3 | 126 | /// INJECTIONGAIN : as GAIN, but with gain values taken as EMELEC factory values |
9bf6860b | 127 | /// GAINCONSTANTCAPA : as GAIN, but with a channel-dependent capacitance value |
128 | ||
129 | return fCalibrationMode.Data(); | |
130 | } | |
131 | ||
3304fa09 | 132 | //_____________________________________________________________________________ |
133 | AliMUONRecoParam *AliMUONRecoParam::GetLowFluxParam() | |
134 | { | |
135 | /// Return default reconstruction parameters for low flux environment | |
136 | ||
137 | AliMUONRecoParam *param = new AliMUONRecoParam(); | |
138 | param->SetLowFluxParam(); | |
139 | ||
140 | return param; | |
141 | } | |
142 | ||
143 | //_____________________________________________________________________________ | |
144 | AliMUONRecoParam *AliMUONRecoParam::GetHighFluxParam() | |
145 | { | |
146 | /// Return default reconstruction parameters for high flux environment | |
147 | ||
148 | AliMUONRecoParam *param = new AliMUONRecoParam(); | |
149 | param->SetHighFluxParam(); | |
150 | ||
151 | return param; | |
152 | } | |
153 | ||
0e894e58 | 154 | //_____________________________________________________________________________ |
155 | AliMUONRecoParam *AliMUONRecoParam::GetCosmicParam() | |
156 | { | |
157 | /// Return default reconstruction parameters for high flux environment | |
158 | ||
159 | AliMUONRecoParam *param = new AliMUONRecoParam(); | |
160 | param->SetCosmicParam(); | |
161 | ||
162 | return param; | |
163 | } | |
164 | ||
c6e702f8 | 165 | //_____________________________________________________________________________ |
166 | AliMUONRecoParam *AliMUONRecoParam::GetCalibrationParam() | |
167 | { | |
168 | /// Return default (dummy) reconstruction parameters for calibration environment | |
169 | ||
170 | AliMUONRecoParam *param = new AliMUONRecoParam(); | |
171 | param->SetCalibrationParam(); | |
172 | ||
173 | return param; | |
174 | } | |
175 | ||
176 | ||
3304fa09 | 177 | //_____________________________________________________________________________ |
178 | void AliMUONRecoParam::SetLowFluxParam() | |
179 | { | |
180 | /// Set reconstruction parameters for low flux environment | |
181 | ||
ad3c6eda | 182 | SetNameTitle("Low Flux","Low Flux"); |
183 | SetEventSpecie(AliRecoParam::kLowMult); | |
e8ec0154 | 184 | fMinBendingMomentum = 0.8; |
185 | fMaxBendingMomentum = 1.e10; | |
9bf6860b | 186 | fMaxNonBendingSlope = 0.3; |
9f093251 | 187 | fMaxBendingSlope = 0.4; |
6b191dea | 188 | fSelectTrackOnSlope = kFALSE; |
189 | fNonBendingVertexDispersion = 70.; | |
190 | fBendingVertexDispersion = 70.; | |
9bf6860b | 191 | fMaxNonBendingDistanceToTrack = 1.; |
192 | fMaxBendingDistanceToTrack = 1.; | |
3304fa09 | 193 | fSigmaCutForTracking = 6.; |
194 | fSigmaCutForImprovement = 5.; | |
bdfb6eef | 195 | fSigmaCutForTrigger = 4.; |
b5270f21 | 196 | fStripCutForTrigger = 1.; |
197 | fMaxStripAreaForTrigger = 3.; | |
bdfb6eef | 198 | fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger; |
6cac085d | 199 | fCombinedClusterTrackReco = kFALSE; |
3304fa09 | 200 | fTrackAllTracks = kTRUE; |
201 | fRecoverTracks = kTRUE; | |
202 | fMakeTrackCandidatesFast = kFALSE; | |
9bf6860b | 203 | fMakeMoreTrackCandidates = kFALSE; |
3304fa09 | 204 | fComplementTracks = kTRUE; |
205 | fImproveTracks = kTRUE; | |
5c15a68b | 206 | fRemoveConnectedTracksInSt12 = kFALSE; |
3304fa09 | 207 | fUseSmoother = kTRUE; |
35be7ed7 | 208 | for (Int_t iCh = 0; iCh < 10; iCh++) { |
209 | fUseChamber[iCh] = kTRUE; | |
210 | fDefaultNonBendingReso[iCh] = 0.144; | |
211 | fDefaultBendingReso[iCh] = 0.01; | |
212 | } | |
9bf6860b | 213 | for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE; |
004a9ccd | 214 | fBypassSt45 = 0; |
89c8d66d | 215 | fMaxTriggerTracks = 100; |
ece56eb9 | 216 | fMaxTrackCandidates = 10000; |
3304fa09 | 217 | } |
218 | ||
219 | //_____________________________________________________________________________ | |
220 | void AliMUONRecoParam::SetHighFluxParam() | |
221 | { | |
222 | /// Set reconstruction parameters for high flux environment | |
223 | ||
ad3c6eda | 224 | SetNameTitle("High Flux","High Flux"); |
225 | SetEventSpecie(AliRecoParam::kHighMult); | |
e8ec0154 | 226 | fMinBendingMomentum = 0.8; |
227 | fMaxBendingMomentum = 1.e10; | |
9bf6860b | 228 | fMaxNonBendingSlope = 0.3; |
9f093251 | 229 | fMaxBendingSlope = 0.4; |
6b191dea | 230 | fSelectTrackOnSlope = kFALSE; |
231 | fNonBendingVertexDispersion = 70.; | |
232 | fBendingVertexDispersion = 70.; | |
9bf6860b | 233 | fMaxNonBendingDistanceToTrack = 1.; |
234 | fMaxBendingDistanceToTrack = 1.; | |
3304fa09 | 235 | fSigmaCutForTracking = 6.; |
236 | fSigmaCutForImprovement = 5.; | |
bdfb6eef | 237 | fSigmaCutForTrigger = 4.; |
b5270f21 | 238 | fStripCutForTrigger = 1.; |
239 | fMaxStripAreaForTrigger = 3.; | |
bdfb6eef | 240 | fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger; |
6cac085d | 241 | fCombinedClusterTrackReco = kFALSE; |
3304fa09 | 242 | fTrackAllTracks = kTRUE; |
243 | fRecoverTracks = kTRUE; | |
244 | fMakeTrackCandidatesFast = kFALSE; | |
9bf6860b | 245 | fMakeMoreTrackCandidates = kFALSE; |
3304fa09 | 246 | fComplementTracks = kTRUE; |
247 | fImproveTracks = kTRUE; | |
c59f70b9 | 248 | fRemoveConnectedTracksInSt12 = kFALSE; |
3304fa09 | 249 | fUseSmoother = kTRUE; |
35be7ed7 | 250 | for (Int_t iCh = 0; iCh < 10; iCh++) { |
251 | fUseChamber[iCh] = kTRUE; | |
252 | fDefaultNonBendingReso[iCh] = 0.144; | |
253 | fDefaultBendingReso[iCh] = 0.01; | |
254 | } | |
9bf6860b | 255 | for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE; |
004a9ccd | 256 | fBypassSt45 = 0; |
89c8d66d | 257 | fMaxTriggerTracks = 100; |
258 | fMaxTrackCandidates = 10000; | |
3304fa09 | 259 | } |
260 | ||
0e894e58 | 261 | //_____________________________________________________________________________ |
262 | void AliMUONRecoParam::SetCosmicParam() | |
263 | { | |
264 | /// Set reconstruction parameters for high flux environment | |
265 | ||
ad3c6eda | 266 | SetNameTitle("Cosmic","Cosmic"); |
267 | SetEventSpecie(AliRecoParam::kCosmic); | |
e8ec0154 | 268 | fMinBendingMomentum = 0.8; |
269 | fMaxBendingMomentum = 1.e10; | |
270 | fMaxNonBendingSlope = 0.3; | |
271 | fMaxBendingSlope = 0.4; | |
6b191dea | 272 | fSelectTrackOnSlope = kTRUE; |
e8ec0154 | 273 | fNonBendingVertexDispersion = 170.; |
274 | fBendingVertexDispersion = 170.; | |
6b191dea | 275 | fMaxNonBendingDistanceToTrack = 1.; |
276 | fMaxBendingDistanceToTrack = 1.; | |
89c8d66d | 277 | fSigmaCutForTracking = 7.; |
6dbd970f | 278 | fSigmaCutForImprovement = 6.; |
bdfb6eef | 279 | fSigmaCutForTrigger = 4.; |
54355f2c | 280 | fStripCutForTrigger = 1.5; |
281 | fMaxStripAreaForTrigger = 3.; | |
bdfb6eef | 282 | fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger; |
0e894e58 | 283 | fPercentOfFullClusterInESD = 100.; |
284 | fCombinedClusterTrackReco = kFALSE; | |
285 | fTrackAllTracks = kTRUE; | |
286 | fRecoverTracks = kTRUE; | |
287 | fMakeTrackCandidatesFast = kFALSE; | |
288 | fMakeMoreTrackCandidates = kFALSE; | |
289 | fComplementTracks = kTRUE; | |
290 | fImproveTracks = kTRUE; | |
c59f70b9 | 291 | fRemoveConnectedTracksInSt12 = kTRUE; |
0e894e58 | 292 | fUseSmoother = kTRUE; |
293 | fSaveFullClusterInESD = kTRUE; | |
35be7ed7 | 294 | for (Int_t iCh = 0; iCh < 10; iCh++) { |
295 | fUseChamber[iCh] = kTRUE; | |
e8ec0154 | 296 | fDefaultNonBendingReso[iCh] = 0.4; |
297 | fDefaultBendingReso[iCh] = 0.4; | |
35be7ed7 | 298 | } |
e8ec0154 | 299 | fRequestStation[0] = kTRUE; |
300 | fRequestStation[1] = kTRUE; | |
301 | fRequestStation[2] = kTRUE; | |
6dbd970f | 302 | fRequestStation[3] = kTRUE; |
303 | fRequestStation[4] = kTRUE; | |
004a9ccd | 304 | fBypassSt45 = 0; |
7eafe398 | 305 | 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 |
89c8d66d | 306 | fMaxTriggerTracks = 100; |
307 | fMaxTrackCandidates = 10000; | |
110edb51 | 308 | |
6dbd970f | 309 | SetPedMeanLimits(20, 700); |
310 | SetManuOccupancyLimits(-1.,0.01); // reject manu above occ=1% | |
ece56eb9 | 311 | |
b3d57767 | 312 | SetBuspatchOccupancyLimits(-1,0.05); |
313 | SetFractionOfBuspatchOutsideOccupancyLimit(0.10); // 10 % | |
0e894e58 | 314 | } |
315 | ||
c6e702f8 | 316 | |
317 | //_____________________________________________________________________________ | |
318 | void AliMUONRecoParam::SetCalibrationParam() | |
319 | { | |
320 | /// Set (dummy) reconstruction parameters for calibration environment | |
321 | ||
322 | SetNameTitle("Calibration","Calibration"); | |
323 | SetEventSpecie(AliRecoParam::kCalib); | |
324 | ||
325 | fPedMeanLimits[0] = 5000; | |
326 | fPedMeanLimits[1] = 0; | |
327 | ||
328 | fPadGoodnessMask = 0x8C00; // Pedestal is missing | is too low | too high | |
329 | ||
330 | } | |
331 | ||
c59f70b9 | 332 | //_____________________________________________________________________________ |
333 | UInt_t | |
334 | AliMUONRecoParam::RequestedStationMask() const | |
335 | { | |
336 | /// Get the mask of the requested station, i.e. an integer where | |
337 | /// bit n is set to one if the station n was requested | |
338 | ||
339 | UInt_t m(0); | |
340 | ||
341 | for ( Int_t i = 0; i < 5; ++i ) | |
342 | { | |
343 | if ( RequestStation(i) ) m |= ( 1 << i ); | |
344 | } | |
345 | return m; | |
346 | } | |
347 | ||
3304fa09 | 348 | //_____________________________________________________________________________ |
349 | void AliMUONRecoParam::Print(Option_t *option) const | |
350 | { | |
351 | /// print reconstruction parameters | |
352 | /// if option = FULL then print also unused parameters | |
353 | ||
4348af6f | 354 | cout<<endl<<"\t------MUON Reconstruction parameters ("<<GetName()<<")------"<<endl; |
ad3c6eda | 355 | |
356 | if (IsDefault()) cout<<"\t\t*** Parameters used by default ***"<<endl; | |
3304fa09 | 357 | |
de98fdc9 | 358 | cout<<Form("Calibration mode = %s",fCalibrationMode.Data())<<endl; |
3304fa09 | 359 | cout<<Form("Clustering mode = %s",fClusteringMode.Data())<<endl; |
3304fa09 | 360 | cout<<Form("Tracking mode = %s",fTrackingMode.Data())<<endl; |
9bf6860b | 361 | |
004a9ccd | 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; | |
3304fa09 | 378 | |
15d30ed4 | 379 | if (fCombinedClusterTrackReco) cout<<"Combined cluster/track reconstruction: ON"<<endl; |
380 | else cout<<"Combined cluster/track reconstruction: OFF"<<endl; | |
38bcf0ef | 381 | |
0a18ba02 | 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; | |
9bdbee64 | 384 | |
6b191dea | 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; | |
9f093251 | 391 | |
6b191dea | 392 | cout<<Form("Vertex dispersion (used to estimate initial bending momentum resolution) = (%5.2f,%5.2f)",fNonBendingVertexDispersion,fBendingVertexDispersion)<<endl; |
3304fa09 | 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; | |
fda59e58 | 397 | |
398 | cout<<Form("Sigma cut for trigger hit pattern = %5.2f",fSigmaCutForTrigger)<<endl; | |
b5270f21 | 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 | ||
3304fa09 | 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 | ||
9bf6860b | 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 | ||
3304fa09 | 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 | ||
c59f70b9 | 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 | ||
3304fa09 | 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 | ||
9bf6860b | 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 | ||
35be7ed7 | 480 | cout << Form("Pad goodness policy mask is 0x%x",PadGoodnessMask()) << endl; |
481 | cout << "Which means we reject pads having the condition = " << | |
482 | AliMUONPadStatusMaker::AsCondition(PadGoodnessMask()).Data() << endl; | |
483 | ||
484 | cout << "The pad limits we are using are :" << endl; | |
485 | ||
486 | cout << Form("%5.0f <= HVSt12 <= %5.0f Volts",HVSt12LowLimit(),HVSt12HighLimit()) << endl; | |
487 | cout << Form("%5.0f <= HVSt345 <= %5.0f Volts",HVSt345LowLimit(),HVSt345HighLimit()) << endl; | |
488 | cout << Form("%7.2f <= Pedestal mean <= %7.2f",PedMeanLowLimit(),PedMeanHighLimit()) << endl; | |
489 | cout << Form("%7.2f <= Pedestal sigma <= %7.2f",PedSigmaLowLimit(),PedSigmaHighLimit()) << endl; | |
490 | cout << Form("%e <= Gain linear term <= %e",GainA1LowLimit(),GainA1HighLimit()) << endl; | |
491 | cout << Form("%e <= Gain quadratic term <= %e",GainA2LowLimit(),GainA2HighLimit()) << endl; | |
492 | cout << Form("%5.0f <= Gain threshold term <= %5.0f",GainThresLowLimit(),GainThresHighLimit()) << endl; | |
7eafe398 | 493 | |
170f4046 | 494 | cout << Form("And we cut on charge >= %7.2f x ( pedestal sigma ) ",ChargeSigmaCut()) << endl; |
495 | ||
7eafe398 | 496 | cout << "Occupancy limits are :" << endl; |
497 | ||
ece56eb9 | 498 | cout << Form("%e <= Manu occupancy < %7.2f",ManuOccupancyLowLimit(),ManuOccupancyHighLimit()) << endl; |
499 | cout << Form("%e <= Buspatch occupancy < %7.2f",BuspatchOccupancyLowLimit(),BuspatchOccupancyHighLimit()) << endl; | |
500 | cout << Form("%e <= DE occupancy < %7.2f",DEOccupancyLowLimit(),DEOccupancyHighLimit()) << endl; | |
501 | ||
502 | cout << "'QAChecker' limits" << endl; | |
ece56eb9 | 503 | cout << Form("FractionOfBuspatchOutsideOccupancyLimit = %5.2f %%",FractionOfBuspatchOutsideOccupancyLimit()*100.0) << endl; |
b3d57767 | 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 | } | |
7eafe398 | 513 | |
35be7ed7 | 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; | |
89c8d66d | 520 | cout<<Form("maximum number of trigger tracks above which the tracking is cancelled = %d",fMaxTriggerTracks)<<endl; |
aa2b81a1 | 521 | cout<<Form("maximum number of track candidates above which the tracking is abandonned = %d",fMaxTrackCandidates)<<endl; |
110edb51 | 522 | |
523 | cout << Form("The average noise pad charge is assumed to be %7.2f fC",AverageNoisePadCharge()) << endl; | |
c11ea7d4 | 524 | cout << Form("and clusters below %5.2f times this noise charge (i.e. %7.2f fC) are discarded", |
110edb51 | 525 | ClusterChargeCut(),ClusterChargeCut()*AverageNoisePadCharge()) << endl; |
526 | cout << Form("Note that LowestPadCharge is then %7.2f fC",LowestPadCharge()) << endl; | |
35be7ed7 | 527 | |
9074a9a9 | 528 | if (TryRecover()) |
529 | { | |
530 | cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl; | |
531 | cout << "!!! WILL TRY TO RECOVER CORRUPTED RAW DATA !!!" << endl; | |
532 | cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl; | |
533 | } | |
4348af6f | 534 | cout<<"\t-----------------------------------------------------"<<endl<<endl; |
3304fa09 | 535 | |
536 | } | |
537 | ||
004a9ccd | 538 | //_____________________________________________________________________________ |
539 | void | |
540 | AliMUONRecoParam::SetDefaultLimits() | |
541 | { | |
542 | /// Set the default limits and pad goodness policy | |
543 | ||
544 | fHVSt12Limits[0]=1500; | |
545 | fHVSt12Limits[1]=2000; | |
546 | ||
547 | fHVSt345Limits[0]=1500; | |
548 | fHVSt345Limits[1]=2000; | |
549 | ||
6dbd970f | 550 | fPedMeanLimits[0] = 20; |
004a9ccd | 551 | fPedMeanLimits[1] = 1024; |
552 | ||
89c8d66d | 553 | fPedSigmaLimits[0] = 0.6; |
004a9ccd | 554 | fPedSigmaLimits[1] = 100; |
555 | ||
556 | fGainA1Limits[0] = 0.1; | |
557 | fGainA1Limits[1] = 10; | |
558 | ||
559 | fGainA2Limits[0] = -1E30; | |
560 | fGainA2Limits[1] = 1E30; | |
561 | ||
562 | fGainThresLimits[0] = 0; | |
563 | fGainThresLimits[1] = 4095; | |
564 | ||
7eafe398 | 565 | fPadGoodnessMask = 0x8080; // Ped is missing | HV is missing |
566 | ||
567 | fManuOccupancyLimits[0] = -1.0; | |
568 | fManuOccupancyLimits[1] = 1.0; | |
569 | ||
ece56eb9 | 570 | fBuspatchOccupancyLimits[0] = 1E-6; |
7eafe398 | 571 | fBuspatchOccupancyLimits[1] = 1.0; |
572 | ||
573 | fDEOccupancyLimits[0] = -1.0; | |
574 | fDEOccupancyLimits[1] = 1.0; | |
2b8a1212 | 575 | |
b3d57767 | 576 | fMissingPadFractionLimit = -1; // DEPRECATED |
577 | fFractionOfBuspatchOutsideOccupancyLimit = 0.10; // 10 % | |
ece56eb9 | 578 | |
110edb51 | 579 | 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) |
580 | ||
581 | AverageNoisePadCharge(0.22875); // 0.22875 coulombs ~ 1.5 ADC channels | |
582 | ||
583 | ClusterChargeCut(2.0); // will cut cluster below 2.0 x LowestPadCharge() | |
b3d57767 | 584 | |
585 | SetEventSizeLimits(35.0,45.0); | |
586 | ||
587 | SetTokenLostLimit(0.0); | |
9074a9a9 | 588 | |
589 | fTryRecover = kFALSE; | |
590 | } | |
591 | ||
592 | ||
593 | //----------------------------------------------------------------------- | |
594 | TObjArray* | |
595 | AliMUONRecoParam::Create(const char* settings) | |
596 | { | |
597 | /// Create pre-defined recoparam array, according to settings. | |
598 | /// settings is case-insensitive. | |
599 | /// | |
600 | /// Currently defined are : | |
601 | /// | |
602 | /// "cosmics" : | |
603 | /// Cosmic (default) | |
604 | /// Calibration | |
605 | /// "ppideal" | |
606 | /// LowFlux (default) | |
607 | /// Calibration | |
608 | /// "ppreal" | |
609 | /// LowFlux (modified to reconstruct real p-p data) | |
610 | /// Calibration | |
611 | /// "pprealsim" | |
612 | /// LowFlux (modified to reconstruct realistic p-p simulation) | |
613 | /// Calibration | |
614 | ||
615 | AliMUONRecoParam* param(0x0); | |
616 | ||
617 | AliRecoParam::EventSpecie_t defaultParam = AliRecoParam::kLowMult; | |
618 | ||
619 | TString stype(settings); | |
620 | stype.ToLower(); | |
621 | ||
622 | if ( stype == "cosmics" ) | |
623 | { | |
624 | // set parameters for cosmic runs | |
625 | param = AliMUONRecoParam::GetCosmicParam(); | |
626 | defaultParam = AliRecoParam::kCosmic; | |
627 | } | |
628 | else if ( stype == "ppideal" ) | |
629 | { | |
630 | // set default lowFlux parameters | |
631 | param = AliMUONRecoParam::GetLowFluxParam(); | |
632 | } | |
1678f090 | 633 | else if ( stype == "ppreal" || stype == "pprealsim" || stype == "pprealnofield" ) |
9074a9a9 | 634 | { |
635 | // common parameters for p-p data and realistic p-p simu | |
636 | param = AliMUONRecoParam::GetLowFluxParam(); | |
637 | param->SaveFullClusterInESD(kTRUE, 100.); | |
638 | for (Int_t iCh=0; iCh<10; iCh++) | |
639 | { | |
640 | param->SetDefaultNonBendingReso(iCh,0.4); | |
641 | param->SetDefaultBendingReso(iCh,0.4); | |
642 | } | |
643 | param->SetSigmaCutForTracking(7.); | |
644 | param->SetStripCutForTrigger(1.5); | |
645 | param->SetSigmaCutForTrigger(6.); | |
646 | param->ImproveTracks(kTRUE, 6.); | |
647 | param->SetPedMeanLimits(20, 700); | |
648 | param->SetManuOccupancyLimits(-1.,0.01); | |
649 | param->SetBuspatchOccupancyLimits(-1.,0.01); | |
650 | param->SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 % | |
651 | ||
652 | // specific parameters for p-p data or realistic p-p simu | |
653 | if ( stype == "ppreal" || stype == "pprealnofield" ) | |
654 | { | |
655 | param->SetPadGoodnessMask(0x400BE80); | |
656 | } | |
657 | else | |
658 | { | |
659 | param->SetPadGoodnessMask(0x8080); | |
660 | } | |
661 | ||
662 | if ( stype == "pprealnofield" ) | |
663 | { | |
664 | param->TryRecover(kTRUE); | |
665 | } | |
666 | } | |
667 | else | |
668 | { | |
669 | AliErrorClass("Unknown settings !"); | |
670 | return 0x0; | |
671 | } | |
672 | ||
673 | TObjArray* recoParams = new TObjArray; | |
674 | ||
675 | recoParams->AddLast(param); | |
676 | ||
677 | // set (dummy) parameters for calibration runs | |
678 | param = AliMUONRecoParam::GetCalibrationParam(); | |
679 | recoParams->AddLast(param); | |
680 | ||
681 | // set parameters for Pb-Pb runs | |
682 | // param = AliMUONRecoParam::GetHighFluxParam(); | |
683 | // recoParams.AddLast(param); | |
684 | ||
685 | // identify default parameters (exit if identification failed) | |
686 | Bool_t defaultIsSet = kFALSE; | |
687 | TIter next(recoParams); | |
688 | while ( (param = static_cast<AliMUONRecoParam*>(next())) ) | |
689 | { | |
690 | if (param->GetEventSpecie() == defaultParam) | |
691 | { | |
692 | param->SetAsDefault(); | |
693 | defaultIsSet = kTRUE; | |
694 | } | |
695 | param->Print("FULL"); | |
696 | } | |
697 | ||
698 | if (!defaultIsSet) | |
699 | { | |
700 | AliErrorClass("The default reconstruction parameters are not set! Exiting..."); | |
701 | return 0x0; | |
702 | } | |
703 | ||
704 | return recoParams; | |
004a9ccd | 705 | } |
706 | ||
9074a9a9 | 707 | //______________________________________________________________________________ |
708 | void | |
709 | AliMUONRecoParam::Show(Int_t runNumber, const char* ocdb) | |
710 | { | |
711 | /// Show what we have in the designated OCDB for that run, as far as RecoParams are concerned | |
712 | ||
713 | AliCDBManager::Instance()->SetDefaultStorage(ocdb); | |
714 | AliCDBManager::Instance()->SetRun(runNumber); | |
715 | ||
716 | AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Calib/RecoParam"); | |
717 | ||
718 | if (!entry) return; | |
719 | ||
720 | TObject* o = entry->GetObject(); | |
721 | ||
722 | if ( o->IsA() == TObjArray::Class() ) | |
723 | { | |
724 | TObjArray* array = static_cast<TObjArray*>(o); | |
725 | for ( Int_t i = 0; i <= array->GetLast(); ++i ) | |
726 | { | |
727 | AliDetectorRecoParam* p = static_cast<AliDetectorRecoParam*>(array->At(i)); | |
728 | cout << Form("array[%d]=%s %s %s",i, | |
729 | p ? p->ClassName() : "", | |
730 | p ? AliRecoParam::GetEventSpecieName(AliRecoParam::Convert(p->GetEventSpecie())) :"", | |
731 | p ? ( p->IsDefault() ? "default" : "") : "" ) << endl; | |
732 | } | |
733 | cout << "=========== dumps below ====== " << endl; | |
734 | ||
735 | for ( Int_t i = 0; i <= array->GetLast(); ++i ) | |
736 | { | |
737 | AliDetectorRecoParam* p = static_cast<AliDetectorRecoParam*>(array->At(i)); | |
738 | if ( p ) p->Print(""); | |
739 | } | |
740 | } | |
741 | else | |
742 | { | |
743 | o->Print(); | |
744 | } | |
745 | } |