X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONRecoParam.cxx;h=fafb9b296807b4fd445beb6ef8ddc4f24e9eec3c;hb=0d856c17a10baa340f6efa7f43eb8dae388ddd06;hp=87d1a7024ab7f6de2c21b7d78f523a7fb05d3896;hpb=aa2b81a1303fec6b7096dce09cfc7a11b626b769;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUONRecoParam.cxx b/MUON/AliMUONRecoParam.cxx index 87d1a7024ab..fafb9b29680 100644 --- a/MUON/AliMUONRecoParam.cxx +++ b/MUON/AliMUONRecoParam.cxx @@ -31,8 +31,13 @@ #include "AliRecoParam.h" #include "AliLog.h" +#include "AliCDBManager.h" +#include "AliCDBEntry.h" + #include +using std::cout; +using std::endl; ClassImp(AliMUONRecoParam) @@ -72,11 +77,28 @@ AliMUONRecoParam::AliMUONRecoParam() fRemoveConnectedTracksInSt12(kFALSE), fMaxTriggerTracks(0), fMaxTrackCandidates(0), - fSelectTrackOnSlope(kFALSE) -{ + fSelectTrackOnSlope(kFALSE), + fMissingPadFractionLimit(-1), + fFractionOfBuspatchOutsideOccupancyLimit(0), + fAverageNoisePadCharge(0.22875), + fClusterChargeCut(2.0), + fEventSizeSoftLimit(35.0), + fEventSizeHardLimit(45.0), + fTokenLostLimit(0.0), + fTryRecover(kFALSE), + fDiscardMonoCathodClusters(kFALSE), + fMonoCathodClNonBendingRes(0.), + fMonoCathodClBendingRes(0.) +{ /// Constructor SetNameTitle("Dummy","Dummy"); + for (Int_t iCh = 0; iCh < 10; iCh++) { + fUseChamber[iCh] = kTRUE; + fDefaultNonBendingReso[iCh] = 0.; + fDefaultBendingReso[iCh] = 0.; + } + for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE; SetDefaultLimits(); } @@ -106,6 +128,7 @@ AliMUONRecoParam::GetCalibrationMode() const /// NOGAIN : only do pedestal subtraction /// GAIN : do pedestal subtraction, and apply gain correction, but with a /// single capacitance value for all channels + /// INJECTIONGAIN : as GAIN, but with gain values taken as EMELEC factory values /// GAINCONSTANTCAPA : as GAIN, but with a channel-dependent capacitance value return fCalibrationMode.Data(); @@ -144,6 +167,18 @@ AliMUONRecoParam *AliMUONRecoParam::GetCosmicParam() return param; } +//_____________________________________________________________________________ +AliMUONRecoParam *AliMUONRecoParam::GetCalibrationParam() +{ + /// Return default (dummy) reconstruction parameters for calibration environment + + AliMUONRecoParam *param = new AliMUONRecoParam(); + param->SetCalibrationParam(); + + return param; +} + + //_____________________________________________________________________________ void AliMUONRecoParam::SetLowFluxParam() { @@ -151,8 +186,8 @@ void AliMUONRecoParam::SetLowFluxParam() SetNameTitle("Low Flux","Low Flux"); SetEventSpecie(AliRecoParam::kLowMult); - fMinBendingMomentum = 1.; - fMaxBendingMomentum = 3000.; + fMinBendingMomentum = 0.8; + fMaxBendingMomentum = 1.e10; fMaxNonBendingSlope = 0.3; fMaxBendingSlope = 0.4; fSelectTrackOnSlope = kFALSE; @@ -162,10 +197,10 @@ void AliMUONRecoParam::SetLowFluxParam() fMaxBendingDistanceToTrack = 1.; fSigmaCutForTracking = 6.; fSigmaCutForImprovement = 5.; - fSigmaCutForTrigger = 8.; + fSigmaCutForTrigger = 4.; fStripCutForTrigger = 1.; fMaxStripAreaForTrigger = 3.; - fMaxNormChi2MatchTrigger = 16.; + fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger; fCombinedClusterTrackReco = kFALSE; fTrackAllTracks = kTRUE; fRecoverTracks = kTRUE; @@ -173,7 +208,7 @@ void AliMUONRecoParam::SetLowFluxParam() fMakeMoreTrackCandidates = kFALSE; fComplementTracks = kTRUE; fImproveTracks = kTRUE; - fRemoveConnectedTracksInSt12 = kTRUE; + fRemoveConnectedTracksInSt12 = kFALSE; fUseSmoother = kTRUE; for (Int_t iCh = 0; iCh < 10; iCh++) { fUseChamber[iCh] = kTRUE; @@ -183,8 +218,10 @@ void AliMUONRecoParam::SetLowFluxParam() for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE; fBypassSt45 = 0; fMaxTriggerTracks = 100; - fMaxTrackCandidates = 10000; - + fMaxTrackCandidates = 10000; + fDiscardMonoCathodClusters = kFALSE; + fMonoCathodClNonBendingRes = 10.; + fMonoCathodClBendingRes = 10.; } //_____________________________________________________________________________ @@ -194,8 +231,8 @@ void AliMUONRecoParam::SetHighFluxParam() SetNameTitle("High Flux","High Flux"); SetEventSpecie(AliRecoParam::kHighMult); - fMinBendingMomentum = 1.; - fMaxBendingMomentum = 3000.; + fMinBendingMomentum = 0.8; + fMaxBendingMomentum = 1.e10; fMaxNonBendingSlope = 0.3; fMaxBendingSlope = 0.4; fSelectTrackOnSlope = kFALSE; @@ -205,10 +242,10 @@ void AliMUONRecoParam::SetHighFluxParam() fMaxBendingDistanceToTrack = 1.; fSigmaCutForTracking = 6.; fSigmaCutForImprovement = 5.; - fSigmaCutForTrigger = 8.; + fSigmaCutForTrigger = 4.; fStripCutForTrigger = 1.; fMaxStripAreaForTrigger = 3.; - fMaxNormChi2MatchTrigger = 16.; + fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger; fCombinedClusterTrackReco = kFALSE; fTrackAllTracks = kTRUE; fRecoverTracks = kTRUE; @@ -227,7 +264,9 @@ void AliMUONRecoParam::SetHighFluxParam() fBypassSt45 = 0; fMaxTriggerTracks = 100; fMaxTrackCandidates = 10000; - + fDiscardMonoCathodClusters = kFALSE; + fMonoCathodClNonBendingRes = 10.; + fMonoCathodClBendingRes = 10.; } //_____________________________________________________________________________ @@ -237,21 +276,21 @@ void AliMUONRecoParam::SetCosmicParam() SetNameTitle("Cosmic","Cosmic"); SetEventSpecie(AliRecoParam::kCosmic); - fMinBendingMomentum = 1.; - fMaxBendingMomentum = 10000000.; - fMaxNonBendingSlope = 0.4; - fMaxBendingSlope = 0.5; + fMinBendingMomentum = 0.8; + fMaxBendingMomentum = 1.e10; + fMaxNonBendingSlope = 0.3; + fMaxBendingSlope = 0.4; fSelectTrackOnSlope = kTRUE; - fNonBendingVertexDispersion = 200.; - fBendingVertexDispersion = 200.; + fNonBendingVertexDispersion = 170.; + fBendingVertexDispersion = 170.; fMaxNonBendingDistanceToTrack = 1.; fMaxBendingDistanceToTrack = 1.; fSigmaCutForTracking = 7.; - fSigmaCutForImprovement = 7.; - fSigmaCutForTrigger = 8.; + fSigmaCutForImprovement = 6.; + fSigmaCutForTrigger = 4.; fStripCutForTrigger = 1.5; fMaxStripAreaForTrigger = 3.; - fMaxNormChi2MatchTrigger = 16.; + fMaxNormChi2MatchTrigger = fSigmaCutForTrigger * fSigmaCutForTrigger; fPercentOfFullClusterInESD = 100.; fCombinedClusterTrackReco = kFALSE; fTrackAllTracks = kTRUE; @@ -268,12 +307,40 @@ void AliMUONRecoParam::SetCosmicParam() fDefaultNonBendingReso[iCh] = 0.4; fDefaultBendingReso[iCh] = 0.4; } - for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE; + fRequestStation[0] = kTRUE; + fRequestStation[1] = kTRUE; + fRequestStation[2] = kTRUE; + fRequestStation[3] = kTRUE; + fRequestStation[4] = kTRUE; fBypassSt45 = 0; - fPadGoodnessMask = 0xC00BE80; + 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 fMaxTriggerTracks = 100; fMaxTrackCandidates = 10000; + fDiscardMonoCathodClusters = kFALSE; + fMonoCathodClNonBendingRes = 10.; + fMonoCathodClBendingRes = 10.; + + SetPedMeanLimits(20, 700); + SetManuOccupancyLimits(-1.,0.01); // reject manu above occ=1% + + SetBuspatchOccupancyLimits(-1,0.05); + SetFractionOfBuspatchOutsideOccupancyLimit(0.10); // 10 % +} + + +//_____________________________________________________________________________ +void AliMUONRecoParam::SetCalibrationParam() +{ + /// Set (dummy) reconstruction parameters for calibration environment + SetNameTitle("Calibration","Calibration"); + SetEventSpecie(AliRecoParam::kCalib); + + fPedMeanLimits[0] = 5000; + fPedMeanLimits[1] = 0; + + fPadGoodnessMask = 0x8C00; // Pedestal is missing | is too low | too high + } //_____________________________________________________________________________ @@ -302,6 +369,8 @@ void AliMUONRecoParam::Print(Option_t *option) const if (IsDefault()) cout<<"\t\t*** Parameters used by default ***"<= %5.2f",ichamber,HVLimit(ichamber)) << endl; + } + cout << Form("%7.2f <= Pedestal mean <= %7.2f",PedMeanLowLimit(),PedMeanHighLimit()) << endl; cout << Form("%7.2f <= Pedestal sigma <= %7.2f",PedSigmaLowLimit(),PedSigmaHighLimit()) << endl; cout << Form("%e <= Gain linear term <= %e",GainA1LowLimit(),GainA1HighLimit()) << endl; cout << Form("%e <= Gain quadratic term <= %e",GainA2LowLimit(),GainA2HighLimit()) << endl; cout << Form("%5.0f <= Gain threshold term <= %5.0f",GainThresLowLimit(),GainThresHighLimit()) << endl; - + cout << Form("And we cut on charge >= %7.2f x ( pedestal sigma ) ",ChargeSigmaCut()) << endl; + cout << "Occupancy limits are :" << endl; + + cout << Form("%e <= Manu occupancy < %7.3f",ManuOccupancyLowLimit(),ManuOccupancyHighLimit()) << endl; + cout << Form("%e <= Buspatch occupancy < %7.3f",BuspatchOccupancyLowLimit(),BuspatchOccupancyHighLimit()) << endl; + cout << Form("%e <= DE occupancy < %7.3f",DEOccupancyLowLimit(),DEOccupancyHighLimit()) << endl; + + cout << "'QAChecker' limits" << endl; + cout << Form("FractionOfBuspatchOutsideOccupancyLimit = %5.2f %%",FractionOfBuspatchOutsideOccupancyLimit()*100.0) << endl; + cout << Form("Event size limit = %5.2f KB/event (soft) and %5.2f KB/event (hard)",fEventSizeSoftLimit,fEventSizeHardLimit) << endl; + if ( fTokenLostLimit > 0 ) + { + cout << Form("We tolerate up to %5.2f %% token lost errors per event",fTokenLostLimit) << endl; + } + else + { + cout << "We dot not tolerate any token lost error !" << endl; + } + cout << "chamber non bending resolution = |"; for (Int_t iCh = 0; iCh < 10; iCh++) cout << Form(" %6.3f |",fDefaultNonBendingReso[iCh]); cout << endl; @@ -448,24 +538,81 @@ void AliMUONRecoParam::Print(Option_t *option) const cout << endl; cout<= 0 && chamberId < 10 ) + { + fHVLimit[chamberId]=value; + } + else + { + AliError(Form("chamberId = %d is not a valid chamberId",chamberId)); + } +} - fHVSt12Limits[0]=1500; - fHVSt12Limits[1]=2000; +//_____________________________________________________________________________ +Double_t AliMUONRecoParam::HVLimit(Int_t chamberId) const +{ + /// Get the HV limit for a given chamber + if ( chamberId >= 0 && chamberId < 10 ) + { + return fHVLimit[chamberId]; + } + AliError(Form("chamberId = %d is not a valid chamberId",chamberId)); - fHVSt345Limits[0]=1500; - fHVSt345Limits[1]=2000; + return 0.0; +} - fPedMeanLimits[0] = 50; +//_____________________________________________________________________________ +void +AliMUONRecoParam::SetDefaultLimits() +{ + /// Set the default limits and pad goodness policy + + fHVSt12Limits[0]=1500; // kept for backward compatibility only + fHVSt12Limits[1]=2000; // kept for backward compatibility only + fHVSt345Limits[0]=1500; // kept for backward compatibility only + fHVSt345Limits[1]=2000; // kept for backward compatibility only + + SetHVLimit(-1,1590); // this one is the real HV limit used now + + fPedMeanLimits[0] = 20; fPedMeanLimits[1] = 1024; fPedSigmaLimits[0] = 0.6; @@ -480,9 +627,223 @@ AliMUONRecoParam::SetDefaultLimits() fGainThresLimits[0] = 0; fGainThresLimits[1] = 4095; - fPadGoodnessMask = 0x8008080; // Ped is missing | HV is missing | killed + fPadGoodnessMask = 0x8080; // Ped is missing | HV is missing + + fManuOccupancyLimits[0] = -1.0; + fManuOccupancyLimits[1] = 1.0; + + fBuspatchOccupancyLimits[0] = 1E-6; + fBuspatchOccupancyLimits[1] = 1.0; + + fDEOccupancyLimits[0] = -1.0; + fDEOccupancyLimits[1] = 1.0; + fMissingPadFractionLimit = -1; // DEPRECATED + fFractionOfBuspatchOutsideOccupancyLimit = 0.05; // 5 % + + 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) + + AverageNoisePadCharge(0.22875); // 0.22875 coulombs ~ 1.5 ADC channels + + ClusterChargeCut(2.0); // will cut cluster below 2.0 x LowestPadCharge() + + SetEventSizeLimits(35.0,45.0); - fChargeSigmaCut = 4.0; + SetTokenLostLimit(0.0); + + fTryRecover = kFALSE; } + +//----------------------------------------------------------------------- +TObjArray* +AliMUONRecoParam::Create(const char* settings) +{ + /// Create pre-defined recoparam array, according to settings. + /// settings is case-insensitive. + /// + /// Currently defined are : + /// + /// "cosmics" : + /// Cosmic (default) + /// Calibration + /// "ppideal" + /// LowFlux (default) + /// Calibration + /// "ppreal" + /// LowFlux (modified to reconstruct real p-p data) + /// Calibration + /// "pprealsim" + /// LowFlux (modified to reconstruct realistic p-p simulation) + /// Calibration + /// "pbpbreal" + /// HighFlux (modified to reconstruct real Pb-Pb data) + /// Calibration + + AliMUONRecoParam* param(0x0); + + AliRecoParam::EventSpecie_t defaultParam = AliRecoParam::kLowMult; + + TString stype(settings); + stype.ToLower(); + + if ( stype == "cosmics" ) + { + // set parameters for cosmic runs + param = AliMUONRecoParam::GetCosmicParam(); + defaultParam = AliRecoParam::kCosmic; + } + else if ( stype == "ppideal" ) + { + // set default lowFlux parameters + param = AliMUONRecoParam::GetLowFluxParam(); + } + else if ( stype == "ppreal" || stype == "pprealsim" || stype == "pprealnofield" ) + { + // common parameters for p-p data and realistic p-p simu + param = AliMUONRecoParam::GetLowFluxParam(); + param->SaveFullClusterInESD(kTRUE, 100.); + for (Int_t iCh=0; iCh<10; iCh++) + { + param->SetDefaultNonBendingReso(iCh,0.4); + param->SetDefaultBendingReso(iCh,0.4); + } + param->SetSigmaCutForTracking(7.); + param->SetStripCutForTrigger(1.5); + param->SetSigmaCutForTrigger(6.); + param->ImproveTracks(kTRUE, 6.); + param->SetPedMeanLimits(20, 700); + param->SetManuOccupancyLimits(-1.,0.015); + param->SetBuspatchOccupancyLimits(-1.,0.05); + param->SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 % + param->SetEventSizeLimits(45., 65.); + param->SetHVLimit(0,1550); + param->SetHVLimit(1,1550); + param->SetHVLimit(2,1550); + param->SetHVLimit(3,1550); + + // specific parameters for p-p data or realistic p-p simu + if ( stype == "ppreal" || stype == "pprealnofield" ) + { + param->SetPadGoodnessMask(0x400BE9B); + } + else + { + param->SetPadGoodnessMask(0x8080); + } + + if ( stype == "pprealnofield" ) + { + param->TryRecover(kTRUE); + } + } + else if ( stype == "pbpbreal" || stype == "pbpbrealsim" ) + { + // common parameters for Pb-Pb data and realistic Pb-Pb simu + param = AliMUONRecoParam::GetHighFluxParam(); + defaultParam = AliRecoParam::kHighMult; + param->SaveFullClusterInESD(kTRUE, 100.); + for (Int_t iCh=0; iCh<10; iCh++) + { + param->SetDefaultNonBendingReso(iCh,0.2); + param->SetDefaultBendingReso(iCh,0.2); + } + param->SetSigmaCutForTracking(5.); + param->SetStripCutForTrigger(1.5); + param->SetSigmaCutForTrigger(4.); + param->ImproveTracks(kTRUE, 4.); + param->SetPedMeanLimits(20, 700); + param->SetManuOccupancyLimits(-1.,0.03); + param->SetBuspatchOccupancyLimits(-1.,0.1); // 10 % (this cut not used for the reco anyway) + param->SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 % + param->SetEventSizeLimits(100., 150.); + + // specific parameters for Pb-Pb data or realistic Pb-Pb simu + if ( stype == "pbpbreal" ) + { + param->SetPadGoodnessMask(0x400BE9B); + } + else + { + param->SetPadGoodnessMask(0x8080); + } + } + else + { + AliErrorClass("Unknown settings !"); + return 0x0; + } + + TObjArray* recoParams = new TObjArray; + + recoParams->AddLast(param); + + // set (dummy) parameters for calibration runs + param = AliMUONRecoParam::GetCalibrationParam(); + recoParams->AddLast(param); + + // set parameters for Pb-Pb runs + // param = AliMUONRecoParam::GetHighFluxParam(); + // recoParams.AddLast(param); + + // identify default parameters (exit if identification failed) + Bool_t defaultIsSet = kFALSE; + TIter next(recoParams); + while ( (param = static_cast(next())) ) + { + if (param->GetEventSpecie() == defaultParam) + { + param->SetAsDefault(); + defaultIsSet = kTRUE; + } + param->Print("FULL"); + } + + if (!defaultIsSet) + { + AliErrorClass("The default reconstruction parameters are not set! Exiting..."); + return 0x0; + } + + return recoParams; +} + +//______________________________________________________________________________ +void +AliMUONRecoParam::Show(Int_t runNumber, const char* ocdb) +{ + /// Show what we have in the designated OCDB for that run, as far as RecoParams are concerned + + AliCDBManager::Instance()->SetDefaultStorage(ocdb); + AliCDBManager::Instance()->SetRun(runNumber); + + AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Calib/RecoParam"); + + if (!entry) return; + + TObject* o = entry->GetObject(); + + if ( o->IsA() == TObjArray::Class() ) + { + TObjArray* array = static_cast(o); + for ( Int_t i = 0; i <= array->GetLast(); ++i ) + { + AliDetectorRecoParam* p = static_cast(array->At(i)); + cout << Form("array[%d]=%s %s %s",i, + p ? p->ClassName() : "", + p ? AliRecoParam::GetEventSpecieName(AliRecoParam::Convert(p->GetEventSpecie())) :"", + p ? ( p->IsDefault() ? "default" : "") : "" ) << endl; + } + cout << "=========== dumps below ====== " << endl; + + for ( Int_t i = 0; i <= array->GetLast(); ++i ) + { + AliDetectorRecoParam* p = static_cast(array->At(i)); + if ( p ) p->Print(""); + } + } + else + { + o->Print(); + } +}