X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TRD%2FAliTRDPreprocessorOffline.cxx;h=c6e0ccce7c08d777d05e577b4b27b2cf22ad3b00;hb=6d25aca0da4a85e55eff20fd38e308637172f66f;hp=f44bea6197b2fc9c164342e7dc4aa0488ad9fd8b;hpb=ca7e6e648563e79a22ee5cfe88dd1ef6b1b729d3;p=u%2Fmrichter%2FAliRoot.git diff --git a/TRD/AliTRDPreprocessorOffline.cxx b/TRD/AliTRDPreprocessorOffline.cxx index f44bea6197b..c6e0ccce7c0 100644 --- a/TRD/AliTRDPreprocessorOffline.cxx +++ b/TRD/AliTRDPreprocessorOffline.cxx @@ -46,6 +46,8 @@ #include "TH1I.h" #include "TH2F.h" #include "TH1F.h" +#include "TMath.h" +#include "THnSparse.h" #include "TProfile2D.h" #include "AliTRDCalDet.h" #include "AliTRDCalPad.h" @@ -56,42 +58,85 @@ #include "AliTRDCalibraMode.h" #include "AliTRDCalibraFit.h" #include "AliTRDCalibraVdriftLinearFit.h" +#include "AliTRDCalibraExbAltFit.h" #include "AliTRDPreprocessorOffline.h" #include "AliTRDCalChamberStatus.h" - +#include "AliTRDCalibChamberStatus.h" +#include "AliTRDCommonParam.h" +#include "AliCDBManager.h" +#include "AliCDBEntry.h" +#include "AliTRDdEdxBaseUtils.h" +#include "AliTRDdEdxCalibHistArray.h" +#include "AliTRDdEdxCalibUtils.h" ClassImp(AliTRDPreprocessorOffline) -AliTRDPreprocessorOffline::AliTRDPreprocessorOffline(): + AliTRDPreprocessorOffline::AliTRDPreprocessorOffline(): TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"), fMethodSecond(kTRUE), fNameList("TRDCalib"), fCalDetGainUsed(0x0), fCalDetVdriftUsed(0x0), + fCalDetExBUsed(0x0), fCH2d(0x0), fPH2d(0x0), fPRF2d(0x0), + fSparse(0x0), fAliTRDCalibraVdriftLinearFit(0x0), + fAliTRDCalibraExbAltFit(0x0), fNEvents(0x0), fAbsoluteGain(0x0), - fPlots(new TObjArray(8)), - fCalibObjects(new TObjArray(8)), + fPlots(new TObjArray(kNumCalibObjs)), + fCalibObjects(new TObjArray(kNumCalibObjs)), + fFirstRunGainUsed(0), fVersionGainUsed(0), fSubVersionGainUsed(0), fFirstRunVdriftUsed(0), fVersionVdriftUsed(0), fSubVersionVdriftUsed(0), + fFirstRunExBUsed(0), + fVersionExBUsed(0), + fSubVersionExBUsed(0), + fNoExBUsedInReco(kFALSE), fSwitchOnValidation(kTRUE), fVdriftValidated(kFALSE), + fExBValidated(kFALSE), fT0Validated(kFALSE), fMinStatsVdriftT0PH(800*20), fMinStatsVdriftLinear(800), fMinStatsGain(800), - fMinStatsPRF(600) + fMinStatsPRF(600), + fMinStatsChamberStatus(20), + fMinSingleStatsChamberStatus(0.05), + fBackCorrectGain(kFALSE), + fBackCorrectVdrift(kTRUE), + fNotEnoughStatisticsForTheGain(kFALSE), + fNotEnoughStatisticsForTheVdriftLinear(kFALSE), + fStatusNeg(0), + fStatusPos(0), + fBadCalibValidate(40), + fNoDataValidate(40), + fRMSBadCalibratedGain(20.0), + fRMSBadCalibratedVdrift(20.0), + fRMSBadCalibratedExB(20.0), + fRobustFitDriftVelocity(kTRUE), + fRobustFitExbAlt(kFALSE), + fAlternativeVdrfitFit(kFALSE), + fAlternativeExbAltFit(kFALSE), + fMinNbOfPointVdriftFit(11), + fMethodeGain(0), + fOutliersFitChargeLow(0.03), + fOutliersFitChargeHigh(0.7), + fBeginFitCharge(3.5), + fPHQon(kTRUE), + fDebugPHQon(kFALSE) { // // default constructor // + + memset(fBadCalib, 0, sizeof(Int_t) * 18); + memset(fNoData, 0, sizeof(Int_t) * 18); } //_________________________________________________________________________________________________________________ AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() { @@ -101,15 +146,52 @@ AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() { if(fCalDetGainUsed) delete fCalDetGainUsed; if(fCalDetVdriftUsed) delete fCalDetVdriftUsed; + if(fCalDetExBUsed) delete fCalDetExBUsed; if(fCH2d) delete fCH2d; if(fPH2d) delete fPH2d; if(fPRF2d) delete fPRF2d; + if(fSparse) delete fSparse; + + if(IsPHQon()){ + AliTRDdEdxCalibUtils::DeleteHistArray(); + AliTRDdEdxCalibUtils::DeleteObjArray(); + } + if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit; + if(fAliTRDCalibraExbAltFit) delete fAliTRDCalibraExbAltFit; if(fNEvents) delete fNEvents; if(fAbsoluteGain) delete fAbsoluteGain; if(fPlots) delete fPlots; if(fCalibObjects) delete fCalibObjects; +} +//___________________________________________________________________________________ +void AliTRDPreprocessorOffline::Process(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage) +{ + // + // Process to the gain, vdrift, timeoffset, exb and chamber status calibration + // + + if(SetCalDetGain(startRunNumber,fVersionGainUsed,fSubVersionGainUsed) && SetCalDetVdriftExB(startRunNumber,fVersionVdriftUsed,fSubVersionVdriftUsed,fVersionExBUsed,fSubVersionExBUsed)) { + + CalibVdriftT0(file,startRunNumber,endRunNumber,ocdbStorage); + CalibGain(file,startRunNumber,endRunNumber,ocdbStorage); + CalibChamberStatus(file,startRunNumber,endRunNumber,ocdbStorage); + CalibExbAlt(file,startRunNumber,endRunNumber,ocdbStorage); + + } + + if(IsPHQon()){ + printf("\n AliTRDPreprocessorOffline PHQ on!!\n\n"); + AliTRDdEdxBaseUtils::PrintControl(); + CalibPHQ(file, startRunNumber, endRunNumber, ocdbStorage); + } + else{ + printf("\n AliTRDPreprocessorOffline PHQ off!!\n\n"); + } + + PrintStatus(); + } //___________________________________________________________________________________________________________________ @@ -127,12 +209,13 @@ void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRun // fVdriftValidated = kTRUE; fT0Validated = kTRUE; + fExBValidated = kTRUE; + fNotEnoughStatisticsForTheVdriftLinear = kFALSE; // // 2. extraction of the information // + if(ReadVdriftLinearFitGlobal(file) && fCalDetVdriftUsed && fCalDetExBUsed) AnalyzeVdriftLinearFit(); if(ReadVdriftT0Global(file)) AnalyzeVdriftT0(); - //printf("Finish PH\n"); - if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit(); // // 3. Append QA plots // @@ -142,21 +225,61 @@ void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRun // 4. validate OCDB entries // if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) { - AliError("TRD vdrift OCDB parameters out of range!"); + //AliError("TRD vdrift OCDB parameters out of range!"); fVdriftValidated = kFALSE; } if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) { - AliError("TRD t0 OCDB parameters out of range!"); + //AliError("TRD t0 OCDB parameters out of range!"); fT0Validated = kFALSE; } + if(fSwitchOnValidation==kTRUE && ValidateExB()==kFALSE) { + //AliError("TRD t0 OCDB parameters out of range!"); + fExBValidated = kFALSE; + } // // 5. update of OCDB // // if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage); if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage); + if(fExBValidated) UpdateOCDBExB(startRunNumber,endRunNumber,ocdbStorage); + +} +//___________________________________________________________________________________________________________________ + +void AliTRDPreprocessorOffline::CalibExbAlt(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){ + // + // make calibration of the drift velocity + // Input parameters: + // file - the location of input file + // startRunNumber, endRunNumber - run validity period + // ocdbStorage - path to the OCDB storage + // - if empty - local storage 'pwd' uesed + if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB"; + // + // 1. Initialization + // + + // + // 2. extraction of the information + // + if(ReadExbAltFitGlobal(file)) AnalyzeExbAltFit(); + // + // 3. Append QA plots + // + //MakeDefaultPlots(fVdriftArray,fVdriftArray); + // + // + // 4. validate OCDB entries + // + // + // 5. update of OCDB + // + // + UpdateOCDBExBAlt(startRunNumber,endRunNumber,ocdbStorage); } + //_________________________________________________________________________________________________________________ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){ @@ -169,6 +292,8 @@ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumb // - if empty - local storage 'pwd' uesed if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB"; // + fNotEnoughStatisticsForTheGain = kFALSE; + // // 1. Initialization if(!ReadGainGlobal(file)) return; // @@ -176,8 +301,8 @@ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumb // 2. extraction of the information // AnalyzeGain(); - if(fCalDetGainUsed) CorrectFromDetGainUsed(); - if(fCalDetVdriftUsed) CorrectFromDetVdriftUsed(); + if(fBackCorrectGain) CorrectFromDetGainUsed(); + //if(fBackCorrectVdrift) CorrectFromDetVdriftUsed(); // // 3. Append QA plots // @@ -187,7 +312,7 @@ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumb // 4. validate OCDB entries // if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) { - AliError("TRD gain OCDB parameters out of range!"); + //AliError("TRD gain OCDB parameters out of range!"); return; } // @@ -227,7 +352,7 @@ void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumbe // 4. validate OCDB entries // if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) { - AliError("TRD prf OCDB parameters out of range!"); + //AliError("TRD prf OCDB parameters out of range!"); return; } // @@ -238,8 +363,29 @@ void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumbe } //________________________________________________________________________________________________________________ +void AliTRDPreprocessorOffline::CalibPHQ(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage) +{ + // + // make calibration of puls height Q + // Input parameters: + // startRunNumber, endRunNumber - run validity period + // ocdbStorage - path to the OCDB storage + // - if empty - local storage 'pwd' uesed + // -void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){ + if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB"; + //printf("test %s\n", ocdbStorage.Data()); + + if(!ReadPHQGlobal(file)) return; + + if(!AnalyzePHQ(startRunNumber)) return; + + UpdateOCDBPHQ(startRunNumber,endRunNumber,ocdbStorage); +} + +//________________________________________________________________________________________________________________ + +void AliTRDPreprocessorOffline::CalibChamberStatus(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){ // // make calibration of the chamber status // Input parameters: @@ -249,6 +395,11 @@ void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t e if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB"; // // + // 1. Initialization + if(!ReadStatusGlobal(file)) return; + // + // + // // 2. extraction of the information // if(!AnalyzeChamberStatus()) return; @@ -262,14 +413,15 @@ void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t e // 4. validate OCDB entries // if(fSwitchOnValidation==kTRUE && ValidateChamberStatus()==kFALSE) { - AliError("TRD Chamber status OCDB parameters not ok!"); + //AliError("TRD Chamber status OCDB parameters not ok!"); return; } // // 5. update of OCDB // // - UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage); + if((!fNotEnoughStatisticsForTheVdriftLinear) && (!fNotEnoughStatisticsForTheGain)) UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage); + //UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage); } //______________________________________________________________________________________________________ @@ -292,18 +444,63 @@ Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){ if(ReadGainGlobal(fileName)) { TString namech = fCH2d->GetTitle(); + fFirstRunGainUsed = GetFirstRun(namech); fVersionGainUsed = GetVersion(namech); fSubVersionGainUsed = GetSubVersion(namech); //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed); } + + if(ReadVdriftLinearFitGlobal(fileName)) { + + TString namelinear = fAliTRDCalibraVdriftLinearFit->GetNameCalibUsed(); + fFirstRunExBUsed = GetFirstRun(namelinear); + fVersionExBUsed = GetVersion(namelinear); + fSubVersionExBUsed = GetSubVersion(namelinear); + + //printf("Found Version %d, Subversion %d, run %d for ExB\n",fVersionExBUsed,fSubVersionExBUsed,fFirstRunExBUsed); + + } + if(fVersionVdriftUsed == 0) fStatusPos = fStatusPos |kVdriftErrorOld; + if(fVersionGainUsed == 0) fStatusPos = fStatusPos | kGainErrorOld; + return kTRUE; } //___________________________________________________________________________________________________________________ +Bool_t AliTRDPreprocessorOffline::ReadStatusGlobal(const Char_t* fileName){ + // + // read calibration entries from file + // + if(fSparse) return kTRUE; + TFile fcalib(fileName); + TObjArray * array = (TObjArray*)fcalib.Get(fNameList); + if (array){ + fSparse = (THnSparseI *) array->FindObject("NumberOfEntries"); + if(!fSparse) return kFALSE; + } + else + return kFALSE; + + return kTRUE; + +} +//___________________________________________________________________________________________________________________ + +Bool_t AliTRDPreprocessorOffline::ReadPHQGlobal(const Char_t* fileName) +{ + // + // read calibration entries from file + // + + return AliTRDdEdxCalibUtils::ReadHistArray(fileName, fNameList); +} + +//___________________________________________________________________________________________________________________ + Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){ // // read calibration entries from file @@ -378,6 +575,28 @@ Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileNa } return kTRUE; +} +//_____________________________________________________________________________________________________________ +Bool_t AliTRDPreprocessorOffline::ReadExbAltFitGlobal(const Char_t* fileName){ + // + // read calibration entries from file + // + if(fAliTRDCalibraExbAltFit) return kTRUE; + TFile fcalib(fileName); + TObjArray * array = (TObjArray*)fcalib.Get(fNameList); + if (array){ + fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) array->FindObject("AliTRDCalibraExbAltFit"); + //fNEvents = (TH1I *) array->FindObject("NEvents"); + }else{ + fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) fcalib.Get("AliTRDCalibraExbAltFit"); + //fNEvents = (TH1I *) fcalib.Get("NEvents"); + } + if(!fAliTRDCalibraExbAltFit) { + //printf("No AliTRDCalibraExbAltFit\n"); + return kFALSE; + } + return kTRUE; + } //_____________________________________________________________________________________________________________ @@ -413,6 +632,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){ // AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance(); + calibra->ChooseMethod(fMethodeGain); + calibra->SetBeginFitCharge(fBeginFitCharge); + calibra->SetFitOutliersChargeLow(fOutliersFitChargeLow); + calibra->SetFitOutliersChargeHigh(fOutliersFitChargeHigh); calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit calibra->AnalyseCH(fCH2d); @@ -428,7 +651,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){ if ((nbtg > 0) && (nbfit >= 0.5*nbE) && (nbE > 30)) { // create the cal objects - if(!fCalDetGainUsed) { + if(!fBackCorrectGain) { calibra->PutMeanValueOtherVectorFit(1,kTRUE); meanother = kTRUE; } @@ -441,6 +664,36 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){ // ok = kTRUE; } + else { + fNotEnoughStatisticsForTheGain = kTRUE; + Int_t minStatsGain = fMinStatsGain*30; + calibra->SetMinEntries(minStatsGain); // Because we do it for all, we increase this + Double_t gainoverallnotnormalized = calibra->AnalyseCHAllTogether(fCH2d); + if(fCalDetGainUsed && (gainoverallnotnormalized > 0.0)) { + AliTRDCalDet *calDetGain = new AliTRDCalDet(*fCalDetGainUsed); + Double_t oldmean = fCalDetGainUsed->CalcMean(kFALSE); + //printf("oldmean %f\n",oldmean); + if(oldmean > 0.0) { + Double_t scalefactor = calibra->GetScaleFactorGain(); + //printf("Correction factor %f\n",gainoverallnotnormalized*scalefactor); + calDetGain->Multiply(gainoverallnotnormalized*scalefactor/oldmean); + //printf("newmean %f\n",calDetGain->CalcMean(kFALSE)); + TH1F *coefGain = calDetGain->MakeHisto1DAsFunctionOfDet(); + fCalibObjects->AddAt(calDetGain,kGain); + fPlots->AddAt(coefGain,kGain); + // + ok = kTRUE; + fStatusNeg = fStatusNeg | kGainNotEnoughStatsButFill; + } + else { + fStatusPos = fStatusPos | kGainErrorOld; + } + } + else { + if(gainoverallnotnormalized <= 0.0) fStatusNeg = fStatusNeg | kGainNotEnoughStatsNotFill; + if(!fCalDetGainUsed) fStatusPos = fStatusPos | kGainErrorOld; + } + } calibra->ResetVectorFit(); @@ -497,6 +750,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){ // ok = kTRUE; } + else { + //printf("Not enough stats timeoffset\n"); + fStatusNeg = fStatusNeg | kTimeOffsetNotEnoughStatsNotFill; + } calibra->ResetVectorFit(); return ok; @@ -510,10 +767,18 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){ //printf("Analyse linear fit\n"); + AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance(); + calibra->SetCalDetVdriftExB(fCalDetVdriftUsed,fCalDetExBUsed); calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit + printf("The mean stat is by %d for VdriftLinear\n",fMinStatsVdriftLinear); //printf("Fill PE Array\n"); - fAliTRDCalibraVdriftLinearFit->FillPEArray(); + fAliTRDCalibraVdriftLinearFit->SetRobustFit(fRobustFitDriftVelocity); + fAliTRDCalibraVdriftLinearFit->SetMinNumberOfPointsForFit(fMinNbOfPointVdriftFit); + if(!fAlternativeVdrfitFit) + fAliTRDCalibraVdriftLinearFit->FillPEArray(); + else + fAliTRDCalibraVdriftLinearFit->FillPEArray2(); //printf("AliTRDCalibraFit\n"); calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit); //printf("After\n"); @@ -538,6 +803,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){ object = calibra->GetVectorFit2(); AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object); TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet(); + //if(!calDetLorentz) printf("No lorentz created\n"); // Put them in the array fCalibObjects->AddAt(calDetVdrift,kVdriftLinear); fCalibObjects->AddAt(calDetLorentz,kLorentzLinear); @@ -546,6 +812,97 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){ // ok = kTRUE; } + else { + fNotEnoughStatisticsForTheVdriftLinear = kTRUE; + Int_t minNumberOfEntriesForAll = fMinStatsVdriftLinear*30; + calibra->SetMinEntries(minNumberOfEntriesForAll); // Because we do it for all, we increase this + Double_t vdriftoverall = -100.0; + Double_t exboverall = 100.0; + calibra->AnalyseLinearFittersAllTogether(fAliTRDCalibraVdriftLinearFit,vdriftoverall,exboverall); + //printf("Found mean vdrift %f and exb %f\n",vdriftoverall,exboverall); + if(fCalDetVdriftUsed && (vdriftoverall > 0.0) && (exboverall < 70.0)) { + AliTRDCalDet *calDetVdrift = new AliTRDCalDet(*fCalDetVdriftUsed); + AliTRDCalDet *calDetLorentz = new AliTRDCalDet(*fCalDetExBUsed); + Double_t oldmeanvdrift = fCalDetVdriftUsed->CalcMean(kFALSE); + Double_t oldmeanexb = fCalDetExBUsed->CalcMean(kFALSE); + //printf("oldmean %f\n",oldmean); + if((oldmeanvdrift > 0.0) && (oldmeanexb < 70.0)) { + //printf("Correction factor %f\n",vdriftoverall); + calDetVdrift->Multiply(vdriftoverall/oldmeanvdrift); + if(TMath::Abs(oldmeanexb) > 0.0001) calDetLorentz->Multiply(exboverall/oldmeanexb); + //printf("newmean %f\n",calDetVdrift->CalcMean(kFALSE)); + TH1F *coefDriftLinear = calDetVdrift->MakeHisto1DAsFunctionOfDet(); + TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet(); + // Put them in the array + fCalibObjects->AddAt(calDetVdrift,kVdriftLinear); + fCalibObjects->AddAt(calDetLorentz,kLorentzLinear); + fPlots->AddAt(coefDriftLinear,kVdriftLinear); + fPlots->AddAt(coefLorentzAngle,kLorentzLinear); + // + ok = kTRUE; + fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsButFill; + } + else { + if(oldmeanvdrift) fStatusPos = fStatusPos | kVdriftErrorOld; + if(oldmeanexb) fStatusPos = fStatusPos | kExBErrorOld; + } + } + else { + if((vdriftoverall <= 0.0) && (exboverall > 70.0)) fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsNotFill; + if(!fCalDetVdriftUsed) fStatusPos = fStatusPos | kVdriftErrorOld; + if(!fCalDetExBUsed) fStatusPos = fStatusPos | kExBErrorOld; + } + } + + calibra->ResetVectorFit(); + + return ok; + +} +//________________________________________________________________________________________________________________ + +Bool_t AliTRDPreprocessorOffline::AnalyzeExbAltFit(){ + // + // Analyze vdrift linear fit - produce the calibration objects + // + + //printf("Analyse linear fit\n"); + + + AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance(); + calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit + //printf("Fill PE Array\n"); + fAliTRDCalibraExbAltFit->SetRobustFit(fRobustFitExbAlt); + if(!fAlternativeExbAltFit) + fAliTRDCalibraExbAltFit->FillPEArray(); + else + fAliTRDCalibraExbAltFit->FillPEArray2(); + //printf("AliTRDCalibraFit\n"); + calibra->AnalyseExbAltFit(fAliTRDCalibraExbAltFit); + //printf("After\n"); + + //Int_t nbtg = 540; + Int_t nbfit = calibra->GetNumberFit(); + Int_t nbE = calibra->GetNumberEnt(); + + + Bool_t ok = kFALSE; + // enough statistics + if ((nbfit >= 0.5*nbE) && (nbE > 30)) { + // create the cal objects + //calibra->RemoveOutliers(1,kTRUE); + calibra->PutMeanValueOtherVectorFit2(1,kTRUE); + // + TObjArray object = calibra->GetVectorFit2(); + AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectExbAlt(&object); + TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet(); + //if(!calDetLorentz) printf("No lorentz created\n"); + // Put them in the array + fCalibObjects->AddAt(calDetLorentz,kExbAlt); + fPlots->AddAt(coefLorentzAngle,kExbAlt); + // + ok = kTRUE; + } calibra->ResetVectorFit(); @@ -590,6 +947,44 @@ Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){ } +//_____________________________________________________________________________ +Bool_t AliTRDPreprocessorOffline::AnalyzePHQ(Int_t startRunNumber) +{ + // + //Produce PHQ calibration results + // + TList *lout = 0x0; + TTreeSRedirector *calibStream = 0x0; + if(IsDebugPHQon()){ + lout = new TList; + lout->SetOwner(); + + calibStream = new TTreeSRedirector(Form("TRDCalibStream_%010d.root", startRunNumber)); + } + + for(Int_t iter=0; iterGetSize(); iter++){ + THnBase *hi = (THnBase*) AliTRDdEdxCalibUtils::GetHistAt(iter); + TObjArray *obji = AliTRDdEdxCalibUtils::HistToObj(hi, startRunNumber, lout, calibStream); + //printf("test analyze %s\n", obji->GetName()); + AliTRDdEdxCalibUtils::GetObjArray()->AddAt(obji, iter); + } + + fCalibObjects->AddAt(AliTRDdEdxCalibUtils::GetObjArray(), kPHQ); + + if(lout){ + TFile *fout=new TFile(Form("TRDCalibList_%010d.root", startRunNumber),"recreate"); + fout->cd(); + lout->Write(); + fout->Save(); + fout->Close(); + delete fout; + } + delete calibStream; + delete lout; + + return kTRUE; +} + //_____________________________________________________________________________ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() { @@ -597,29 +992,36 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() // Produce AliTRDCalChamberStatus out of calibration results // - // set up AliTRDCalChamberStatus - AliTRDCalChamberStatus *CalChamberStatus = new AliTRDCalChamberStatus(); - for(Int_t det = 0; det < 540; det++) CalChamberStatus->SetStatus(det,1); + // set up AliTRDCalibChamberStatus + AliTRDCalibChamberStatus *chamberStatus = new AliTRDCalibChamberStatus(); + chamberStatus->SetSparseI(fSparse); + chamberStatus->AnalyseHisto(fMinStatsChamberStatus, fMinSingleStatsChamberStatus); + // get AliTRDCalChamberStatus + AliTRDCalChamberStatus *calChamberStatus = chamberStatus->GetCalChamberStatus(); // get calibration objects AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain); AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear); + AliTRDCalDet *calDetExB = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear); // Check - if((!calDetGain) || (!calDetVDrift) || (!fCH2d)) return kFALSE; + if((!calDetGain) || (!calDetVDrift) || (!fCH2d) || (!calDetExB) || (!calChamberStatus)) return kFALSE; // Gain - Double_t gainmean = calDetGain->GetMean(); + Double_t gainmean = calDetGain->GetMean(); Double_t vdriftmean = calDetVDrift->GetMean(); + Double_t exbmean = calDetExB->GetMean(); - Double_t gainrms = calDetGain->GetRMSRobust(); - Double_t vdriftrms = calDetVDrift->GetRMSRobust(); + Double_t gainrms = calDetGain->GetRMSRobust(); + Double_t vdriftrms = calDetVDrift->GetRMSRobust(); + Double_t exbrms = calDetExB->GetRMSRobust(); //printf("Gain mean: %f, rms: %f\n",gainmean,gainrms); //printf("Vdrift mean: %f, rms: %f\n",vdriftmean,vdriftrms); - + //printf("ExB mean: %f, rms: %f\n",exbmean,exbrms); + // Check - if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001)) return kFALSE; + if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001) || (TMath::Abs(exbrms) < 0.0000001)) return kFALSE; // mask chambers with empty gain entries //Int_t counter = 0; @@ -628,6 +1030,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() // ch2d TH1I *projch = (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e"); Double_t entries = projch->GetEntries(); + //printf("Number of entries %f for det %d\n",entries,idet); // gain Double_t gain = calDetGain->GetValue(idet); @@ -635,47 +1038,60 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() // vdrift Double_t vdrift = calDetVDrift->GetValue(idet); + // exb + Double_t exb = calDetExB->GetValue(idet); + - if(entries<=0.5 || - TMath::Abs(gainmean-gain) > (15.0*gainrms) || - TMath::Abs(vdriftmean-vdrift) > (15.0*vdriftrms)) { + if( (entries<50 && !calChamberStatus->IsNoData(idet)) || + TMath::Abs(gainmean-gain) > (fRMSBadCalibratedGain*gainrms) || + TMath::Abs(vdriftmean-vdrift) > (fRMSBadCalibratedVdrift*vdriftrms) || + TMath::Abs(exbmean-exb) > (fRMSBadCalibratedExB*exbrms) ) { //printf(" chamber det %03d masked \n",idet); //printf(" gainmean %f and gain %f, gainrms %f \n",gainmean,gain,gainrms); //printf(" vdriftmean %f and vdrift %f, vdriftrms %f \n",vdriftmean,vdrift,vdriftrms); - CalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kMasked); + //printf(" exbmean %f and exb %f, exbrms %f \n",exbmean,exb,exbrms); + + calChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kBadCalibrated); //counter++; } - /* - // installed supermodules+1 -> abort - if(counter > (7+1)*30) { - printf("ERROR: more than one SM to be masked!! \n Abort...\n"); - if(projch) delete projch; - return 0x0; - } - */ - delete projch; } - // Security - for(Int_t sm=0; sm < 18; sm++) { - Int_t counter = 0; - for(Int_t det = 0; det < 30; det++){ - Int_t detector = sm*30+det; - if(CalChamberStatus->IsMasked(detector)) counter++; - } - if(counter >= 10) { - for(Int_t det = 0; det < 30; det++){ - Int_t detector = sm*30+det; - CalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kInstalled); - } - } - } - - fCalibObjects->AddAt(CalChamberStatus,kChamberStatus); + // Security + for(Int_t sm=0; sm < 18; sm++) { + Int_t smnodata = 0; + Int_t smbadcalib = 0; + for(Int_t det = 0; det < 30; det++){ + Int_t detector = sm*30+det; + if(calChamberStatus->IsNoData(detector)) smnodata++; + else { + if(calChamberStatus->IsBadCalibrated(detector)) smbadcalib++; + } + } + fNoData[sm] = smnodata; + fBadCalib[sm]= smbadcalib; + //printf("No Data %d, bad calibrated %d for %d\n",fNoData[sm],fBadCalib[sm],sm); + } + + // Security + // for(Int_t sm=0; sm < 18; sm++) { + // Int_t counter = 0; + // for(Int_t det = 0; det < 30; det++){ + // Int_t detector = sm*30+det; + // if(calChamberStatus->IsBadCalibrated(detector)) counter++; + // } + // if(counter >= 20) { + // for(Int_t det = 0; det < 30; det++){ + // Int_t detector = sm*30+det; + // calChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood); + // } + // } + // } + + fCalibObjects->AddAt(calChamberStatus,kChamberStatus); return kTRUE; } @@ -711,8 +1127,18 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() Float_t gaininit = fCalDetGainUsed->GetValue(det); Float_t gainout = calDetGain->GetValue(det); - if(TMath::Abs(gainout-1.0) > 0.000001) calDetGain->SetValue(det,gaininit*gainout); - else calDetGain->SetValue(det,mean); + if(TMath::Abs(gainout-1.0) > 0.000001) { + Double_t newgain = gaininit*gainout; + if(newgain < 0.1) newgain = 0.1; + if(newgain > 1.9) newgain = 1.9; + calDetGain->SetValue(det,newgain); + } + else { + Double_t newgain = mean; + if(newgain < 0.1) newgain = 0.1; + if(newgain > 1.9) newgain = 1.9; + calDetGain->SetValue(det,newgain); + } } @@ -734,21 +1160,37 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() if(!calDetVdrift) return; // Calculate mean - - for(Int_t det = 0; det < 540; det++) { - - Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det); - Float_t vdriftout = calDetVdrift->GetValue(det); - - Float_t gain = calDetGain->GetValue(det); - if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout; - calDetGain->SetValue(det,gain); - - + if(!fNotEnoughStatisticsForTheVdriftLinear) { + for(Int_t det = 0; det < 540; det++) { + + Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det); + Float_t vdriftout = calDetVdrift->GetValue(det); + + Float_t gain = calDetGain->GetValue(det); + if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout; + if(gain < 0.1) gain = 0.1; + if(gain > 1.9) gain = 1.9; + calDetGain->SetValue(det,gain); + } } - + else { + + Float_t vdriftinit = fCalDetVdriftUsed->CalcMean(kFALSE); + Float_t vdriftout = calDetVdrift->CalcMean(kFALSE); + Float_t factorcorrectif = 1.0; + if(vdriftout > 0.0) factorcorrectif = vdriftinit/vdriftout; + for(Int_t det = 0; det < 540; det++) { + Float_t gain = calDetGain->GetValue(det); + gain = gain*factorcorrectif; + if(gain < 0.1) gain = 0.1; + if(gain > 1.9) gain = 1.9; + calDetGain->SetValue(det,gain); + } + + } + } - //_________________________________________________________________________________________________________________ +//_________________________________________________________________________________________________________________ void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ // // Update OCDB entry @@ -757,6 +1199,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() AliCDBMetaData *metaData= new AliCDBMetaData(); metaData->SetObjectClassName("AliTRDCalDet"); metaData->SetResponsible("Raphaelle Bailhache"); + metaData->AddDateToComment(); metaData->SetBeamPeriod(1); AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber); @@ -766,6 +1209,54 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() } + //___________________________________________________________________________________________________________________ + void AliTRDPreprocessorOffline::UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ + // + // Update OCDB entry + // + + Int_t detExB = kLorentzLinear; + if(!fMethodSecond) return; + + //printf("Pass\n"); + + AliCDBMetaData *metaData= new AliCDBMetaData(); + metaData->SetObjectClassName("AliTRDCalDet"); + metaData->SetResponsible("Raphaelle Bailhache"); + metaData->AddDateToComment(); + metaData->SetBeamPeriod(1); + + AliCDBId id1("TRD/Calib/ChamberExB", startRunNumber, endRunNumber); + AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath); + AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB); + if(calDet) gStorage->Put(calDet, id1, metaData); + //if(!calDet) printf("No caldet\n"); + + } +//___________________________________________________________________________________________________________________ +void AliTRDPreprocessorOffline::UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ + // + // Update OCDB entry + // + + Int_t detExB = kExbAlt; + if(!fMethodSecond) return; + + //printf("Pass\n"); + + AliCDBMetaData *metaData= new AliCDBMetaData(); + metaData->SetObjectClassName("AliTRDCalDet"); + metaData->SetResponsible("Theo Rascanu"); + metaData->AddDateToComment(); + metaData->SetBeamPeriod(1); + + AliCDBId id1("TRD/Calib/ChamberExBAlt", startRunNumber, endRunNumber); + AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath); + AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB); + if(calDet) gStorage->Put(calDet, id1, metaData); + //if(!calDet) printf("No caldet\n"); + +} //___________________________________________________________________________________________________________________ void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ // @@ -779,6 +1270,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() AliCDBMetaData *metaData= new AliCDBMetaData(); metaData->SetObjectClassName("AliTRDCalDet"); metaData->SetResponsible("Raphaelle Bailhache"); + metaData->AddDateToComment(); metaData->SetBeamPeriod(1); AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber); @@ -793,6 +1285,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() AliCDBMetaData *metaDataPad= new AliCDBMetaData(); metaDataPad->SetObjectClassName("AliTRDCalPad"); metaDataPad->SetResponsible("Raphaelle Bailhache"); + metaDataPad->AddDateToComment(); metaDataPad->SetBeamPeriod(1); AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber); @@ -811,6 +1304,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() AliCDBMetaData *metaData= new AliCDBMetaData(); metaData->SetObjectClassName("AliTRDCalDet"); metaData->SetResponsible("Raphaelle Bailhache"); + metaData->AddDateToComment(); metaData->SetBeamPeriod(1); AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber); @@ -823,6 +1317,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() AliCDBMetaData *metaDataPad= new AliCDBMetaData(); metaDataPad->SetObjectClassName("AliTRDCalPad"); metaDataPad->SetResponsible("Raphaelle Bailhache"); + metaDataPad->AddDateToComment(); metaDataPad->SetBeamPeriod(1); AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber); @@ -841,8 +1336,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() AliCDBMetaData *metaData= new AliCDBMetaData(); metaData->SetObjectClassName("AliTRDCalPad"); metaData->SetResponsible("Raphaelle Bailhache"); + metaData->AddDateToComment(); metaData->SetBeamPeriod(1); + AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber); AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath); AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF); @@ -850,6 +1347,27 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() } +//_________________________________________________________________________________________________________________ +void AliTRDPreprocessorOffline::UpdateOCDBPHQ(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath) +{ + // + // Update OCDB entry + // + AliCDBMetaData *metaData= new AliCDBMetaData(); + metaData->SetObjectClassName("TObjArray"); + metaData->SetResponsible("Raphaelle Bailhache and Xianguo Lu"); + metaData->AddDateToComment(); + metaData->SetBeamPeriod(1); + + AliCDBId id1("TRD/Calib/PHQ", startRunNumber, endRunNumber); + AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath); + TObjArray *cobj = (TObjArray *) fCalibObjects->At(kPHQ); + if(cobj){ + //cobj->Print(); + gStorage->Put(cobj, id1, metaData); + } +} + //_________________________________________________________________________________________________________________ void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ // @@ -858,7 +1376,8 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() AliCDBMetaData *metaData= new AliCDBMetaData(); metaData->SetObjectClassName("AliTRDCalChamberStatus"); - metaData->SetResponsible("Raphaelle Bailhache"); + metaData->SetResponsible("Raphaelle Bailhache and Julian Book"); + metaData->AddDateToComment(); metaData->SetBeamPeriod(1); AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber); @@ -869,7 +1388,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() } //__________________________________________________________________________________________________________________________ - Bool_t AliTRDPreprocessorOffline::ValidateGain() const { + Bool_t AliTRDPreprocessorOffline::ValidateGain() { // // Validate OCDB entry // @@ -880,9 +1399,13 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() Double_t rms = calDet->GetRMSRobust(); if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE; //if((mean > 0.2) && (mean < 1.4)) return kTRUE; - else return kFALSE; + else { + fStatusPos = fStatusPos | kGainErrorRange; + return kFALSE; + } } else return kFALSE; + } @@ -902,7 +1425,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() Double_t mean = calDet->GetMean(); Double_t rms = calDet->GetRMSRobust(); //printf("Vdrift::mean %f, rms %f\n",mean,rms); - if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE; + if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) { + fStatusPos = fStatusPos | kVdriftErrorRange; + ok = kFALSE; + } } else return kFALSE; @@ -912,13 +1438,36 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() Double_t mean = calPad->GetMean(); Double_t rms = calPad->GetRMS(); //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms); - if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE; + if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) { + fStatusPos = fStatusPos | kVdriftErrorRange; + ok = kFALSE; + } } else return kFALSE; } return ok; + } + //__________________________________________________________________________________________________________________________ + Bool_t AliTRDPreprocessorOffline::ValidateExB(){ + // + // Update OCDB entry + // + + AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear); + if(calDet) { + Double_t mean = calDet->GetMean(); + Double_t rms = calDet->GetRMSRobust(); + //printf("Vdrift::mean %f, rms %f\n",mean,rms); + if(!((mean > -1.0) && (mean < 1.0) && (rms < 0.5))) { + fStatusNeg = fStatusNeg | kExBErrorRange; + return kFALSE; + } + else return kTRUE; + } + else return kFALSE; + } //__________________________________________________________________________________________________________________________ Bool_t AliTRDPreprocessorOffline::ValidateT0(){ @@ -935,7 +1484,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() //Double_t rmspad = calPad->GetRMS(); //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad); if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE; - else return kFALSE; + else { + fStatusPos = fStatusPos | kTimeOffsetErrorRange; + return kFALSE; + } } else return kFALSE; @@ -959,23 +1511,35 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus() } //__________________________________________________________________________________________________________________________ -Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus() const{ +Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus(){ // // Update OCDB entry // AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus); if(calChamberStatus) { - Int_t detectormasked = 0; - for(Int_t det = 0; det < 540; det++) { - if(calChamberStatus->IsMasked(det)) detectormasked++; + + Int_t detectornodata = 0; + Int_t detectorbadcalib = 0; + + for(Int_t sm=0; sm < 18; sm++) { + //printf("%d chambers w/o data in sm %d\n",fNoData[sm],sm); + //printf("%d bad calibrated chambers in sm %d\n",fBadCalib[sm],sm); + if(fNoData[sm] != 30) detectornodata += fNoData[sm]; + detectorbadcalib+=fBadCalib[sm]; } - //printf("Number of chambers masked %d\n",detectormasked); - if(detectormasked > 29) return kFALSE; - else return kTRUE; + //printf("Number of chambers w/o data %d\n",detectornodata); + //printf("Number of chambers bad calibrated %d\n",detectorbadcalib); + + if((detectornodata > fNoDataValidate) || + (detectorbadcalib > fBadCalibValidate)){ + fStatusPos = fStatusPos | kChamberStatusErrorRange; + return kFALSE; + } + return kTRUE; } else return kFALSE; - + } //_____________________________________________________________________________ Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const @@ -987,12 +1551,14 @@ Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const // Some patterns const Char_t *version = "Ver"; if(!strstr(name.Data(),version)) return -1; - + const Char_t *after = "Subver"; + if(!strstr(name.Data(),after)) return -1; + for(Int_t ver = 0; ver < 999999999; ver++) { TString vertry(version); vertry += ver; - vertry += "Subver"; + vertry += after; //printf("vertry %s and name %s\n",vertry.Data(),name.Data()); @@ -1014,12 +1580,18 @@ Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const // Some patterns const Char_t *subversion = "Subver"; if(!strstr(name.Data(),subversion)) return -1; + const Char_t *after = "FirstRun"; + if(!strstr(name.Data(),after)) { + after = "Nz"; + } + if(!strstr(name.Data(),after)) return -1; + for(Int_t ver = 0; ver < 999999999; ver++) { TString vertry(subversion); vertry += ver; - vertry += "FirstRun"; + vertry += after; //printf("vertry %s and name %s\n",vertry.Data(),name.Data()); @@ -1041,12 +1613,15 @@ Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const // Some patterns const Char_t *firstrun = "FirstRun"; if(!strstr(name.Data(),firstrun)) return -1; + const Char_t *after = "Nz"; + if(!strstr(name.Data(),after)) return -1; + for(Int_t ver = 0; ver < 999999999; ver++) { TString vertry(firstrun); vertry += ver; - vertry += "Nz"; + vertry += after; //printf("vertry %s and name %s\n",vertry.Data(),name.Data()); @@ -1057,6 +1632,162 @@ Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const return -1; } +//_____________________________________________________________________________ +Bool_t AliTRDPreprocessorOffline::CheckStatus(Int_t status, Int_t bitMask) const +{ + // + // Checks the status + // + return (status & bitMask) ? kTRUE : kFALSE; + +} +//_____________________________________________________________________________ +Int_t AliTRDPreprocessorOffline::GetStatus() const +{ + // + // Checks the status + // fStatusPos: errors + // fStatusNeg: only info + // + + if(fStatusPos > 0) return fStatusPos; + else return (-TMath::Abs(fStatusNeg)); + +} +//_____________________________________________________________________________ +void AliTRDPreprocessorOffline::PrintStatus() const +{ + // + // Do Summary + // + + AliInfo(Form("The error status is %d",fStatusPos)); + AliInfo(Form("IsGainErrorOld? %d",(Int_t)IsGainErrorOld())); + AliInfo(Form("IsVdriftErrorOld? %d",(Int_t)IsVdriftErrorOld())); + AliInfo(Form("IsGainErrorRange? %d",(Int_t)IsGainErrorRange())); + AliInfo(Form("IsVdriftErrorRange? %d",(Int_t)IsVdriftErrorRange())); + AliInfo(Form("IsTimeOffsetErrorRange? %d",(Int_t)IsTimeOffsetErrorRange())); + AliInfo(Form("IsChamberStatusErrorRange? %d",(Int_t)IsChamberStatusErrorRange())); + + + AliInfo(Form("The info status is %d",fStatusNeg)); + AliInfo(Form("IsGainNotEnoughStatsButFill? %d",(Int_t)IsGainNotEnoughStatsButFill())); + AliInfo(Form("IsVdriftNotEnoughStatsButFill? %d",(Int_t)IsVdriftNotEnoughStatsButFill())); + AliInfo(Form("IsGainNotEnoughStatsNotFill? %d",(Int_t)IsGainNotEnoughStatsNotFill())); + AliInfo(Form("IsVdriftNotEnoughStatsNotFill? %d",(Int_t)IsVdriftNotEnoughStatsNotFill())); + AliInfo(Form("IsTimeOffsetNotEnoughStatsNotFill? %d",(Int_t)IsTimeOffsetNotEnoughStatsNotFill())); + + AliInfo(Form("IsExBErrorRange? %d",(Int_t)IsExBErrorRange())); + AliInfo(Form("IsExBErrorOld? %d",(Int_t)IsExBErrorOld())); + +} +//___________________________________________________________________________________ +void AliTRDPreprocessorOffline::SetCalDetVdrift(AliTRDCalDet *calDetVdriftUsed) +{ + fCalDetVdriftUsed = calDetVdriftUsed; + + fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)"); + for(Int_t k = 0; k < 540; k++){ + fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k))); + //printf("Set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k)); + } + +}; +//___________________________________________________________________________________ +Bool_t AliTRDPreprocessorOffline::SetCalDetGain(Int_t runNumber, Int_t version, Int_t subversion) +{ + // + // Set the fCalDetGainUsed + // + + if((version == 0) && (subversion == 0)) return kFALSE; + + AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor",runNumber, version, subversion); + if(!entry) { + AliError("Found no entry\n"); + fStatusPos = fStatusPos | kGainErrorOld; + return kFALSE; + } + //const AliCDBId id = entry->GetId(); + //version = id.GetVersion(); + //subversion = id.GetSubVersion(); + //printf("Found version %d and subversion %d for vdrift\n",version,subversion); + AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject(); + if(calDet) fCalDetGainUsed = calDet; + else { + fStatusPos = fStatusPos | kGainErrorOld; + return kFALSE; + } + + return kTRUE; + +} +//___________________________________________________________________________________ +Bool_t AliTRDPreprocessorOffline::SetCalDetVdriftExB(Int_t runNumber, Int_t versionv, Int_t subversionv, Int_t versionexb, Int_t subversionexb) +{ + // + // Set the fCalDetVdriftUsed and fCalDetExBUsed + // + + if((versionv == 0) && (subversionv == 0)) return kFALSE; + + AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberVdrift",runNumber, versionv, subversionv); + if(!entry) { + AliError("Found no entry\n"); + fStatusPos = fStatusPos | kVdriftErrorOld; + return kFALSE; + } + AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject(); + if(calDet) fCalDetVdriftUsed = calDet; + else { + fStatusPos = fStatusPos | kVdriftErrorOld; + return kFALSE; + } + + // ExB object + + if((versionexb == 0) && (subversionexb == 0)) { + + fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)"); + for(Int_t k = 0; k < 540; k++){ + fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k))); + //printf("Nothing found: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k)); + } + } + else { + + entry = 0x0; + entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberExB",runNumber, versionexb, subversionexb); + if(!entry) { + //printf("Found no entry\n"); + fStatusPos = fStatusPos | kExBErrorOld; + return kFALSE; + } + AliTRDCalDet* calDetexb = (AliTRDCalDet *)entry->GetObject(); + if(!calDetexb) { + fStatusPos = fStatusPos | kExBErrorOld; + return kFALSE; + } + + Double_t meanexb = calDetexb->GetMean(); + //printf("Mean value %f\n",meanexb); + if((meanexb > 70) || (fNoExBUsedInReco)) { + fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)"); + for(Int_t k = 0; k < 540; k++){ + fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k))); + //printf("Found but: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k)); + } + } + else { + fCalDetExBUsed = calDetexb; + } + + } + + + return kTRUE; + +}